[Linked List]Partition List

Total Accepted: 53879 Total Submissions: 190701 Difficulty: Medium

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.

/**
 * 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* pivot           = NULL;
        ListNode* cur             = head;
        ListNode* insert_pos      = cur;
        ListNode* insert_pos_pre  = NULL;
        while(cur && cur->val < x){
            insert_pos_pre = cur;
            cur = cur->next;
            insert_pos = cur;
        }
        pivot = cur;
        
        /*
        pivot 左边做插入，insert_node_pre,inser_node
        pivot 右边做删除, delete_node_pre,delete_node
        */
    
        ListNode* possible_delete_node_pre = pivot;
        ListNode* possible_delete_node     = pivot ? pivot->next : NULL;
        
        while(possible_delete_node){
            ListNode* possible_delete_node_next = possible_delete_node->next;
            if(possible_delete_node->val < x){
                if(insert_pos_pre){
                    insert_pos_pre->next = possible_delete_node    ;
                }else{
                    head = possible_delete_node;
                }
                possible_delete_node->next = insert_pos;
                
                insert_pos_pre = possible_delete_node;
                insert_pos = insert_pos_pre->next;
                
                possible_delete_node_pre ->next = possible_delete_node_next;
               
            }else{
                possible_delete_node_pre = possible_delete_node;
            }
            possible_delete_node     = possible_delete_node_next;
        }
        
        return head;
        
    }
};

Next challenges: (H) Minimum Window Substring (H) Longest Substring with At Most Two Distinct Characters (M) Two Sum II - Input array is sorted