[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,
Given1->4->3->2->5->2and x = 3,
return1->2->2->4->3->5.

题意：给定一个链表和一个值x，将它划分为所有小于x的节点出现在大于或等于x的节点之前。值得注意的是，不要改变相对顺序，对1->4->3->2->5->2而言，给定x=4则返回1->3->2->2->4->5，前半段不应是按递增的顺序，但相对位置不变即可。

思路：找到第一个值不小x的结点和其前驱pre，然后从该结点往后遍历，找到值小于x结点，然后将其依次放在前驱之后，对于前驱pre则不断的向其后继移动。

方法一：初始代码：思想是，找到第一个大于或者等于x的值及其前驱，然后从x开始向后遍历，但是在遍历的过程，需要用到x前驱的信息，所以又重新定义了一个新的变量preCur。

/**
 * 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 *nList=new ListNode(0);
        nList->next=head;
        ListNode *pre=nList;
        ListNode *cur=head;

        while(cur)　　//找到节点及其前驱pre
        {
            if(cur->val >=x)
                break;
            pre=cur;
            cur=cur->next;          

        }    
        ListNode *preCur=cur;　　//cur是不停的向后遍历，preCur则是其前行过程中的前驱
30         
        while(cur)
        {
            if(cur->val <x)
            {
                ListNode *temp=cur->next;
                cur->next=pre->next;
                pre->next=cur;
                preCur->next=temp;
                pre=pre->next;
                cur=temp;
            }
            else
            {
                preCur=cur;
                cur=cur->next;
            }
        }
        return nList->next;    
    }
};

方法一：改进版。很明显，cur为第一个值不小于x的节点，然后通过其后继的值来作为判断前行或是将小于x的节点放在前面，这样就可以省去变量。

/**
 * 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) 
    {
        ListNode *nList=new ListNode(0);
        nList->next=head;
        ListNode *pre=nList;
        ListNode *cur=head;

        while(pre->next&&pre-next->val < x)
            pre=pre->next;

        cur=pre;
        while(cur->next)
        {
            if(cur->next->val <x)
            {
                ListNode *temp=cur->next;
                cur->next=temp->next;
                temp->next=pre->next;
                pre->next=temp;
                pre=pre->next;
            }
            else
            {
                cur=cur->next;
            }
        }
        return nList->next;
    }
};

方法三：可以通过将值小于x的结点全部拿出来组成一个新的链表，然后将这个新的链表插入第一个值不小于x之前即可。来源Grandyang的博客

 class Solution
 {
 public:
    ListNode *partition(ListNode *head,int x)
    {
        if(head==NULL)  return head;
        ListNode *small=new ListNode(-1);
        ListNode *big=new ListNode(-1);

        big->next=head;
        ListNode *cur=small,*p=small;
        while(cur->next)
        {
            if(cur->next->val <x)
            {
                p->next=cur->next;
                p=p->next;
                //小于x的值，不停的移到small中，然后cur重新连接
                cur->next=cur->next->next;  
                p->next=NULL;   //注意要记得给p->next=NULL
            }
            else    
                cur=cur->next;
        }
        p->next=big->next;  //拼接
        return small->next;
    }
 }