链表排序--归并

递归方法的归并排序三部曲：1，快慢指针找中点；2，递归调用mergeSort，3，合并两个链表。

class Solution {
public:
    ListNode* sortList(ListNode* head) {
        return mergeSort(head);
    }
    
    ListNode* mergeSort(ListNode* node) {
        if (!node || !node->next) return node;
        //快慢指针
        ListNode* fast = node;
        ListNode* slow = node;
        ListNode* breakN = node;
        while (fast && fast->next) {
            fast = fast->next->next;
            breakN = slow;
            slow = slow->next;
        }
        breakN->next = nullptr;
        ListNode *l1 = mergeSort(node);
        ListNode *l2 = mergeSort(slow);
        return merge(l1, l2);
    }
    
    ListNode* merge(ListNode* l1, ListNode* l2) {
        //递归到底的情况
        if (l1 == nullptr) return l2;
        if (l2 == nullptr) return l1;
        //分情况递归实现
        if (l1->val <= l2->val) {
            l1->next = merge(l1->next, l2);
            return l1;
        } else {
            l2->next = merge(l2->next, l1);
            return l2;
        }
    }
}

--------------------------------------------

由于题目要求空间复杂度是 O(1)，因此不能使用递归。因此这里使用 bottom-to-up 的算法来解决。

链表里操作最难掌握的应该就是各种断链啊，然后再挂接啊。在这里，我们主要用到链表操作的两个技术：

merge(l1, l2)，双路归并，我相信这个操作大家已经非常熟练的，就不做介绍了。
cut(l, n)，可能有些同学没有听说过，它其实就是一种 split 操作，即断链操作。不过我感觉使用 cut 更准确一些，它表示，将链表 l 切掉前 n 个节点，并返回后半部分的链表头。
额外再补充一个 dummyHead 大法，已经讲过无数次了，仔细体会吧。因为有了dummy之后，所有的节点都变成拥有前置节点的节点了。所以就不用担心处理头节点这个特殊情况了。而且你最后需要返回的仅仅是dummy.next，不用花功夫去保持住你的头结点了。

希望同学们能把双路归并和 cut 断链的代码烂记于心，以后看到类似的题目能够刷到手软。

class Solution {
public:
    ListNode* sortList(ListNode* head) {
        ListNode dummyHead(0);
        dummyHead.next = head;
        auto p = head;
        int length = 0;
        while (p) {
            ++length;
            p = p->next;
        }
        
        for (int size = 1; size < length; size <<= 1) {
            auto cur = dummyHead.next;
            auto tail = &dummyHead;
            
            while (cur) {
                auto left = cur;
                auto right = cut(left, size); // left->@->@ right->@->@->@...
                cur = cut(right, size); // left->@->@ right->@->@  cur->@->...
                
                tail->next = merge(left, right);
                while (tail->next) {
                    tail = tail->next;
                }
            }
        }
        return dummyHead.next;
    }
    
    ListNode* cut(ListNode* head, int n) {
        auto p = head;
        while (--n && p) {
            p = p->next;
        }
        
        if (!p) return nullptr;
        
        auto next = p->next;
        p->next = nullptr;
        return next;
    }
    
    ListNode* merge(ListNode* l1, ListNode* l2) {
        ListNode dummyHead(0);
        auto p = &dummyHead;
        while (l1 && l2) {
            if (l1->val < l2->val) {
                p->next = l1;
                p = l1;
                l1 = l1->next;       
            } else {
                p->next = l2;
                p = l2;
                l2 = l2->next;
            }
        }
        p->next = l1 ? l1 : l2;
        return dummyHead.next;
    }
};

 

---------------------

非递归实现线性表的归并排序：

void merge_sort(int q[] , int l , int r)
{
    if(l >= r) return;

    int mid = l + r >> 1;

    merge_sort(q , l , mid);
    merge_sort(q , mid + 1 , r);

    int k = 0 , i = l , j = mid + 1;

    while(i <= mid && j <= r)

        if(q[i] <= q[j]) temp[k++] = q[i++];
        else temp[k++] = q[j++];

    while(i <= mid) temp[k++] = q[i++];
    while(j <= r) temp[k++] = q[j++];

    for(int i = l , j = 0; i <= r; i++ , j++) q[i] = temp[j];

}

int main()
{
    int n;
    scanf("%d" , &n);
    for(int i = 0;i < n;i++) scanf("%d" , &q[i]);

    merge_sort(q , 0 , n-1);

    for(int i = 0;i < n;i++) printf("%d " , q[i]);

    return 0;
}