leetcode #86 in cpp

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.

Solution:(change the list in place)

We could always use extra space and make the solution easier. Using two lists to store the nodes <x and >=x and then connecting two lists is a much simpler way to solve this problem. However I would like to change the list in place since this is more challenging. 

We should get an answer where there are two sections, the first section is consist of elements < x, and the second of elements >= x. 

Say [1,4,3,2,5,2], x = 3, the final answer is [1,2,2,4,3,5]. There are two sections,the first section is [1,2,2], and the second section is [4,3,5]. 

First we find the first element which is bigger than or equal to x. Mark the parent of this element as the tail of section1, and current element as the head of section 2. Then we continue scanning through the list. If we find an element < x, we append it to the tail of section 1. Note that if we are appending node i to the tail of section 1, we have to 1. change next of parent of node i to node i's next. 2. change tail of section 1's next to node i. 3. change tail of section 1 to node i. 

Code: 

/**
 * 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;
        ListNode *newHead =new ListNode(0);
        
        newHead->next = head;
        ListNode *sect1tail = newHead;
        
        //look for the first value bigger than or equal to x
        while(sect1tail->next && sect1tail->next->val < x){
            sect1tail = sect1tail->next;
        }
        
        if(!sect1tail->next) return head;//if sect1tail reaches the end, return the whole list
        
        ListNode *prev = sect1tail->next;
        ListNode *cur = sect1tail->next;
        //sect1 tail is the tail of the list of nodes < x,sect2 head is the head of the list 
        //bigger than or equal to x
        ListNode *sect2head = sect1tail->next;//the head of the list that is bigger than or equal to x
        while(cur){
            if(cur->val < x){//if cur -> val < x, append it to the sect1 tail
                prev->next = cur->next;
                sect1tail->next = cur;
                sect1tail = sect1tail->next;
                cur = prev->next;
            }
            else{//otherwise proceed
                prev = cur;
                cur = cur->next;
            }
        }
        //connect sect1tail and sect2 head
        sect1tail->next = sect2head;
        return newHead->next;   
    }
};