[Leetcode]#86 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.
https://leetcode.com/problems/partition-list/

//#86 Partition List
//8ms 100%
/**
 * 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 || !head->next) return head;
        //size == 0; size == 1
        ListNode *p1(head), *p2(head);
        if(head->val >= x)
        {
            //insert from the head
            while(p2->next != NULL)
            {
                if(p2->next->val < x)
                {
                    ListNode *tmp(head);
                    head = p2->next;
                    p2->next = p2->next->next;
                    head->next = tmp;
                    break;
                }
                else
                {
                    p2 = p2->next;
                }
            }

            if(p2->next == NULL) return head;
            p1 = head;
        }
        else
        {
            while(p1->next != NULL && p1->next->val < x)
            {
                p1 = p1->next;
            }
            if(p1->next == NULL || p1->next->next == NULL) return head;
            p2 = p1->next;

        }

        while(p2->next != NULL)
        {
            if(p2->next->val < x)
            {
                ListNode *tmp(p1->next);
                p1->next = p2->next;
                p2->next = p2->next->next;
                p1->next->next = tmp;
                p1 = p1->next;
            }
            else
            {
                p2 = p2->next;
            }
        }
        return head;

    }
};