问题描述：

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.

解题思路：

这里其实就是对链表元素进行快速排序的一次划分操作，主要就是用两个指针，一个指针（p_great）用于处理链表的元素，一个指针(p_less)用于元素分界，即在p_less指针之前的元素（包括p_less指针指向的值）全部小于x值，而在p_less和p_great之间的元素全部都大于或等于x值。p_great之后的元素是还没有处理的链表元素。

在代码中，我使用了一个辅助结点，让该结点的值等于x-1，并让其next指向head头指针，这样就可以保证链表的第一个元素肯定小于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) {
        if (NULL == head)
            return head;
        ListNode *p_less, *p_great, *p_parent, *new_head;
        new_head = p_parent = p_less = new ListNode(x-1);/*辅助结点*/
        p_less->next = head;
        p_great = head;
        while (p_great != NULL) {
            if (p_great->val < x) {
                if (p_parent == p_less) {/*链表首部的元素小于给定的值*/
                    p_less = p_less->next;
                    p_parent = p_great;
                    p_great = p_great->next;
                } else {
                    p_parent->next = p_great->next;
                    p_great->next = p_less->next;
                    p_less->next = p_great;
                    p_less = p_great;
                    p_great = p_parent->next;
                }
            } else {
                p_parent = p_great;
                p_great = p_great->next;
            }
        }
        if (new_head->next != head)
            head = new_head->next;
        free(new_head);
        new_head = NULL;
        return head;
    }
};