LeetCode 148. Sort List

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

题意：使用固定的空间复杂度对一个链表在O(n log n)时间复杂度下排序
解决思路：对于链表，不能使用交换排序，可以使用插入排序中的二路归并排序。
1. 我们可以利用一快一慢指针将链表二分，快指针每次移动2步，慢指针每次移动1步，比如：
(0)- 9 - 5 - 7 - 6 - 8 - 4 - 3 - 2 - 1 - 0
—–↑↑
—–f s

(1)- 9 - 5 - 7 - 6 - 8 - 4 - 3 - 2 - 1 - 0
——— ↑ - ↑
——— f – s

(2)- 9 - 5 - 7 - 6 - 8 - 4 - 3 - 2 - 1 - 0
————– ↑ — – ↑
————– f —— s

(3)- 9 - 5 - 7 - 6 - 8 - 4 - 3 - 2 - 1 - 0
—————— ↑ —— — ↑
—————— f ———– s

(4)- 9 - 5 - 7 - 6 - 8 - 4 - 3 - 2 - 1 - 0
—————— — ↑ ———– — ↑
—————— — f ———— — s

(5) s = f -> next; f -> next = NULL; f = head;
- 9 - 5 - 7 - 6 - 8 - 4 - 3 - 2 - 1 - 0
–↑ ——————- ↑
- f ——————- s

2. 分成单个节点时，链表均为有序，再向上合并
比如最后分成了 9 5，我们先连接5，之后再连接9，就变成了 5 - 9
而 7 6 也是同理， 变成了 6 - 7 ，加上8，之后先连接6，再连接7，8
再向上 5 - 9 6 - 7 - 8，同理从两个链表中取小的5，再取6、7、8、9
最后一层就成了 0 - 1 - 2 - 3 - 4 - 5 - 6 - 7 - 8 - 9

/**
 * 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) {
        ListNode *first = head;
        ListNode *second = head;
        if(first == NULL || first -> next == NULL){
            // 为空或只有一个节点则直接返回（递归出口）
            return first;
        }
        while(second -> next != NULL && second -> next -> next != NULL){
            // 利用一块一慢指针二分链表
            first = first -> next;
            second = second -> next -> next;
        }
        if(first -> next != NULL){
            second = first -> next;  // second指针指向二分点
            first -> next = NULL;   // 将整个链表断开为两个
            first = head;           // first指针指向头
        }

        return merge(sortList(first), sortList(second));    
    }

private:
    ListNode* merge(ListNode* first, ListNode* second){
        ListNode* current = new ListNode(0); // 建立哨点
        ListNode* head = current;

        while(first != NULL && second != NULL){
            if(first -> val < second -> val)   // 取较小的节点
                link(current, first);
            else
                link(current, second);
        }

        while(first != NULL)        // 链接剩下的节点
            link(current, first);

        while(second != NULL)
            link(current, second);

        current = head -> next;     // 释放哨点
        delete head;
        return current;
    }

    // 这里必须是引用
    void link(ListNode* &linker, ListNode* &linked){
        linker -> next = linked;
        linker = linker -> next;
        linked = linked -> next;
    }
};

提交结果：