[Leetcode 71] 86 Partition List

Problem:

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.

Analysis:

first parition the list into two sub-lists. sublist1 for those nodes that less than x, sublist 2 for those nodes that greater than or equal to x. Then merge them together. Remember to set the last node's next to NULL.

The split procedure takes O(n) time and the merger procedure takes O(1) time.

It's an in-place algorithm.

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) {
        // Start typing your C/C++ solution below
        // DO NOT write int main() function
        if (head == NULL || head->next == NULL)
            return head;
        
        ListNode *ls, *le, *gs, *ge;
        ls = le = gs = ge = NULL;
        
        // split list
        while (head != NULL) {
            if (head->val < x) {
                if (ls == NULL) {
                    ls = le = head;
                } else  {
                    le->next = head;
                    le = head;
                }
            } else {
                if (gs == NULL) {
                    gs = ge = head;
                } else {
                    ge->next = head;
                    ge = head;
                }
            }
            
            head = head->next;
        }
        
        // merge list
        if (ls == NULL) {
            ls = gs;
            if (ge != NULL)
                ge->next = NULL;
        } else {
            le->next = gs;
            if (ge != NULL)
                ge->next = NULL;
        }
        
        return ls;
    }
};