LeetCode | Partition List

Given a linked list and a value x, partition it such that all nodes
less than x come before nodes greater than or equal to x.

You should preserve the original relative order of the nodes in each
of the two partitions.

For example, Given 1->4->3->2->5->2 and x = 3, return
1->2->2->4->3->5.

题目的意思是从链表里面取出比x小的数据，并按照大小顺序依次排在最前面，而>=它的数据不需要变化
同样，写了一个比较残的，还CE
// 我写了一个head作为新的存储头节点，然后将所有的按照顺序拿到head里面
//哦我似乎看错题意了，不需要排序…

class Solution {
public:
    ListNode* partition(ListNode* head, int x) {
        if(head==NULL || head->next==NULL) return head;
        ListNode root(-1);
        root.next=head;

        ListNode* temp=&root;
        ListNode* head2=temp; 
        //需要遍历整个链表 
        while(temp->next!=NULL) {
            int flag=0;
            //从头部开始向后找，找到比x小的数据
            while(temp->next!=NULL) {
                //获取当前的值 
                int val=temp->next->val;
                if(val<x){
                    flag=1;break;
                }
                temp=temp->next;
            }
            if(flag){
                //当前temp的next的值是需要被提前的
                ListNode* node=temp->next;

                //需要将这个node按照从小到大的顺序，加入head组里面 
                ListNode* t=head2;
                while(t->next!=NULL){
                    if(t->next->val<node->val)
                    t=t->next;
                }
                //目前找到的是第一个比val大的数据的位置，它在t->next里
                //于是当前数据应当插入t和t->next之间
                node->next=t->next;
                t->next=node;

                //原链上这个值需要被跳过 
                temp->next=temp->next->next;
            }
        }
        //结束之后，需要将head2尾部连到root.next上
        ListNode* end=head2;
        while(end->next!=NULL) end=end->next;

        end->next=root.next;
        return head2;
    }
};

正解,还是双指针大法好啊

class Solution {
public:
    ListNode* partition(ListNode* head, int x) {
        //利用双链表，直接将不同大小的数据分流到不同的数组中
        ListNode left(-1);
        ListNode right(-1);

        ListNode* left_cur=&left;
        ListNode* right_cur=&right;

        //ok好好看看链表使用for循环的方法
        for(ListNode* cur=head;cur!=NULL;cur=cur->next){
            if(cur->val<x){
                //从尾部添加
                left_cur->next=cur;
                left_cur=cur;
            }
            else{
                right_cur->next=cur;
                right_cur=cur;
            }
        }

        left_cur->next=right.next;
        right_cur->next=NULL;
        return left.next;
    }
};

于是重写了我的代码，发现一个巨大的缺陷，
就是如果尝试只使用一个head2，而从原数组中采取删除元素的方式
//当然是因为我处理的有点残
会导致head_cur的尾插变为insert操作

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode* partition(ListNode* head, int x) {
        if(head==NULL || head->next==NULL) return head;
        ListNode root(-1);
        ListNode head2(-1);
        root.next=head;

        ListNode* temp=&root;
        ListNode* head_cur=&head2;
        for(;temp!=NULL && temp->next!=NULL;temp=temp==NULL?NULL:temp->next){
            if(temp->next->val<x){
                head_cur->next=temp->next;
                head_cur=head_cur->next;

                //这种方法有个很大的问题在于
                //删除了某个元素之后，上述尾插的方法，有可能会变为insert
                //例如
                // Input:
                //     [1,2,3]
                //     4
                //     Output:
                //     [1,3,2]
                //     Expected:
                //     [1,2,3]
                //删除数组中的这个元素(跳过)
                //temp->next=head_cur==NULL?NULL:head_cur->next;
            }
        }

        //结束之后，需要将head2尾部连到root.next上
        head_cur->next=root.next;
        return head2.next;
    }
};