Sort List

Problem:

Sort a linked list in O(n log n) time using constant space complexity.

分析：

归并排序在数组上操作，归并时需要O(n)的空间，但链表中归并却容易，直接修改指针。分割的操作，利用两个指针，一个一次走一步，一个一次走两步，当走得快的走到末尾时，走得慢的恰好走到中间，这时，就将链表一分为二。递归对划分的两个链表再次分割，直到分割的链表中只有少于等于一个节点，可以直接返回。归并的过程相对容易，不需要额外申请空间与拷贝数据，全是指针操作。

class Solution {
public:
    ListNode *sortList(ListNode *head) {
        // split list into two parts
        if(head == NULL || head->next == NULL)
            return head;
            
        ListNode *slow, *fast;
        slow = fast = head;
        while(fast->next != NULL && fast->next->next != NULL) {
            slow = slow->next;
            fast = fast->next;
            fast = fast->next;
        }
        
        ListNode *list1, *list2;
        list1 = head;
        list2 = slow->next;
        slow->next = NULL;
        
        list1 = sortList(list1);
        list2 = sortList(list2);
        
        // merge two lists
        ListNode *tail = NULL;
        head = NULL;
        while(list1 != NULL && list2 != NULL) {
            if(list1->val < list2->val) {
               if(head == NULL) {
                   head = tail = list1;
               } else {
                   tail->next = list1;
                   tail = tail->next;
               }
               list1 = list1->next;
            } else {
                if(head == NULL) {
                    head = tail = list2;
                } else {
                    tail->next = list2;
                    tail = tail->next;
                }
                list2 = list2->next;
            }
        }
        
        if(list1 != NULL) {
            tail->next = list1;
        }
        
        if(list2 != NULL) {
            tail->next = list2;
        }
        
        return head;
    }
};