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

看到O(n log n)這個複雜度就想到了快速排序法。快速排序法主要思想為取一個基準點，採用交換+分治法完成快速排序。

對於單鏈表的快速排序，不能從後面開始遍歷，因為根據後繼找不到其前驅。因此採用以下步驟：

1.取每次的頭節點為基準節點，然後將這個節點從連結串列分離出來。用兩個指標，從頭節點的下一個節點遍歷。

2.找到一個小於頭節點的值，若是第一個小於頭節點的值，左連結串列的頭指向它，然後繼續遍歷，滿足小於就掛載在左連結串列的後面。相反，建立一個有連結串列。其實還是在原連結串列上建立。

3.使用遞迴分別對左連結串列和右連結串列進行如上操作，當頭節點為NULL時，遞迴返回。當左右連結串列都返回時，將原來的頭節點與左右連結串列掛上。

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode* sortList(ListNode* head) {
        if (head == NULL) {
            return head;
        }
        ListNode* tail = NULL;
        for (tail = head; tail -> next; tail = tail -> next);
        quicksort(head, tail);
        return head;
    }
    
    void quicksort(ListNode* &head, ListNode* &tail) {
        if (head == NULL) {
            return;
        }
        int key = head -> val;
        ListNode* p = head -> next;
        head -> next = NULL;
        ListNode* left_front = NULL, *right_front = NULL;
        ListNode* left_head = NULL, *left_tail = NULL;
        ListNode* right_head = NULL, *right_tail = NULL;
        
        while (p) {
            if (p -> val < key) {  // 與頭節點的值判斷
                if (!left_head) {  // 左連結串列
                    left_head = p;
                    left_front = p;
                }
                else {
                    left_front -> next = p;
                    left_front = p;
                }
                p = p -> next;
                left_front -> next = NULL;
            }
            else {
                if (!right_head) { // 右連結串列
                    right_head = p;
                    right_front = p;
                }
                else {
                    right_front -> next = p;
                    right_front = p;
                }
                p = p -> next;
                right_front -> next = NULL;
            }
        }
        left_tail = left_front;
        right_tail = right_front;
        
        quicksort(left_head, left_tail); // 左連結串列遞迴
        quicksort(right_head, right_tail);// 右連結串列遞迴
        // 左右連結串列遞迴返回，將原先頭節點掛在左右連結串列
        if (left_tail && right_head) { // 左右連結串列都為NULL
            left_tail -> next = head;
            head -> next = right_head;
            head = left_head;
            tail = right_tail;
        }
        else if (left_tail) {  // 右連結串列為NULL
            left_tail -> next = head;
            tail = head;
            head = left_head;
        }
        else if (right_head) {  // 左連結串列為NULL
            head -> next = right_head;
            tail = right_tail;
        }
    } 
};