leet code 86 分隔链表

Posted rulin

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了leet code 86 分隔链表相关的知识,希望对你有一定的参考价值。

原题目(https://leetcode-cn.com/problems/partition-list/):

给定一个链表和一个特定值 x,对链表进行分隔,使得所有小于 x 的节点都在大于或等于 x 的节点之前。

你应当保留两个分区中每个节点的初始相对位置。

示例:

输入: head = 1->4->3->2->5->2, x = 3
输出: 1->2->2->4->3->5

 

第一次做这个题没有注意到结果要保持相对位置不变,把它和快排联系到了一起,快排的partition部分也是有一个类似的方法,我就把链表存储到了vector中,用挖坑法完成了题目,能够把两部分分割开来,但是顺序不对:

class Solution {
public:
    ListNode* partition(ListNode* head, int x) {
        if (head == NULL) {
            return head;
        }
        ListNode* next = head;
        vector<int> vlist;

        while(next != NULL) {
            vlist.emplace_back(next->val);
            next = next->next;
        }
       
        int left = 0;
        int right = vlist.size()-1;

        int dir = 1; //从做往右扫

        while(left < right) {
            if (dir == 1) {
                if (vlist[left] >= x) {
                   dir = -1;
                }
                else {
                    left++;
                }
            }
            else if (dir == -1) {
                if (vlist[right] < x) {
                    //交换两个值
                    int tmp = vlist[right];
                    vlist[right] = vlist[left];
                    vlist[left] = tmp;

                    dir = 1;
                }
                else {
                    right--;
                }
            }
        }

        next = head;
        int index = 0;
        while(next != NULL) {
            next->val = vlist[index];
            index++;
            next = next->next;
        }

        return head;
    }
};

后面看了leetcode官方的解答,看了一眼就看不下去了,在后面又看到另一个简短的c++答案,思想很简单:直接交换就完事了,先判断一下第一个节点是不是大于等于x,后面就是断开链表再连到前面即可,人狠话不多啊,

先介绍下具体的思想:

step 1:如果表头的val比x大,往后找到比x小的节点,把这个节点取出来链接在head前面,再把head指向这个节点;

step 2: 定义两个节点指针,cur和pre,cur始终指向第一个比x大的节点前面的节点,不断移动pre节点寻找val比x小的节点,找到后放在cur后面,将cur跟新为这个新节点

实现的代码如下:

class Solution {
public:
    ListNode* partition(ListNode* head, int x) {
        if (head == NULL) {
            return head;
        }
        
        ListNode* pre = head;

// 将第一个节点替换为比x小的节点
        if (head->val >= x) {
            while (NULL != pre->next) {
                if (pre->next->val < x) {
                    ListNode* tmp = pre->next;
                    pre->next = tmp->next;
                    tmp->next = head;
                    head = tmp;
                    break;
                }
                else {
                    pre = pre->next;
                }
            }
        }

        // 找到比x小的节点并将其
        pre = head;
        ListNode* cur = head;

        while(NULL != pre->next) {
            if (pre->next->val < x) {
                if (pre == cur) {
                    cur = cur->next;
                    pre = pre->next;
                }
                else {
                    ListNode* tmp = pre->next;
                    pre->next = tmp->next;
                    tmp->next = cur->next;
                    cur->next = tmp;
                    cur = tmp;
                }
            }
            else {
                pre = pre->next;
            }
        }

        return head;
    }
};

需要注意的是:遍历链表的方式,我第一开始没有领会这种遍历方法的精髓,只是想着模仿题解写了一个答案,后面我想尝试直接使用node!=NULL作为循环条件,发现不可以,为什么呢?

因为我把节点的父节点丢了,没法完成链表截取了,使用node->next!=NULL进行遍历可以一直保留父节点指针

以上是关于leet code 86 分隔链表的主要内容,如果未能解决你的问题,请参考以下文章

Leet Code OJ 21. Merge Two Sorted Lists [Difficulty: Easy]

LeetCode86. 分隔链表

LeetCode- 86 -分隔链表 - Java - 细喔

Leet Code OJ 203. Remove Linked List Elements [Difficulty: Easy]

86. 分隔链表

Leet Code OJ 83. Remove Duplicates from Sorted List [Difficulty: Easy]