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.  

分析：《Introductin to Alogrithims》讲解quick sort是给出了一种partition array的方法，但是这种方法用在这道题上不好，原因有二。第一，partition array的方法不能preserve the original relative order。第二，partition array中是两个元素不断互换，对于链表来说我们可以采用更高效的方法。在这里，我们定义几个指针，index指向大于等于x的结点段（这个结点段指第一个大于等于x的结点到p之前的结点），p指向当前遍历到的结点，pre_p指向p前一个结点。在partition的时候如果p->val小于x我们只要将p移动到index后面即可（这里的移动包含几个操作，比如处理pre_p->next, p->next）。具体实现时，有两个方面要注意，一是如果p移动到index后面后，遍历的指针应该指向p移动前的next；二是如果index后面是p，即index = pre_p时，操作跟index!=pre_p不同。算法时间复杂度是O(n)，空间复杂度是O(1)。代码如下：

class Solution {
public:
    ListNode *partition(ListNode *head, int x) {
        ListNode * dummy = new ListNode(-1);
        dummy->next = head;
        ListNode * index = dummy;
        ListNode * p = head, * pre_p = dummy;
        while(p){
            if(p->val < x){
                if(pre_p != index){
                    pre_p->next = p->next;
                    p->next = index->next;
                    index->next = p;
                }else pre_p = p;
                index = index->next;
                p = pre_p->next;
            }else{
                pre_p = p;
                p = p->next;
            }
        }
        return dummy->next;
    }
};

出上面的方法外，还有一种更好理解的方法，操作也更简便，我们可以设两个虚拟结点，然后一个虚拟结点后是小于x的结点，另一个虚拟结点后是大于等于x的结点。时间复杂度和空间复杂度亦为O(n)和O(1)。

class Solution {
public:
ListNode* partition(ListNode* head, int x) {
ListNode left_dummy(-1); // 头结点
ListNode right_dummy(-1); // 头结点
auto left_cur = &left_dummy;
auto right_cur = &right_dummy;
for (ListNode *cur = head; cur; 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_dummy.next;
right_cur->next = nullptr;
return left_dummy.next;
}
};

Note:在链表头部加一个dummy结点很多时候可以方便操作简化代码。