LeetCode 148. 排序链表(C++)（自底向上归并排序）

前言：

最适合链表的排序算法是归并排序。

归并排序基于分治算法。最容易想到的实现方式是自顶向下的递归实现，考虑到递归调用的栈空间，自顶向下归并排序的空间复杂度是O(logn)。如果要达到 O(1) 的空间复杂度，则需要使用自底向上的实现方式。

自底向上归并排序

使用自底向上的方法实现归并排序，则可以达到 O(1) 的空间复杂度。
首先求得链表的长度length，然后将链表拆分成子链表进行合并。

具体做法如下。

用 subLength 表示每次需要排序的子链表的长度，初始时subLength=1。
每次将链表拆分成若干个长度为subLength 的子链表（最后一个子链表的长度可以小于 subLength），按照每两个子链表一组进行合并，合并后即可得到若干个长度为subLength×2 的有序子链表（最后一个子链表的长度可以小于 subLength×2）。合并两个子链表仍然使用「21. 合并两个有序链表」的做法。
将 subLength 的值加倍，重复第 2 步，对更长的有序子链表进行合并操作，直到有序子链表的长度大于或等于 length，整个链表排序完毕。

如何保证每次合并之后得到的子链表都是有序的呢？可以通过数学归纳法证明。

初始时subLength=1，每个长度为 1 的子链表都是有序的。
如果每个长度为 subLength 的子链表已经有序，合并两个长度为 subLength 的有序子链表，得到长度为 subLength×2 的子链表，一定也是有序的。
当最后一个子链表的长度小于 subLength 时，该子链表也是有序的，合并两个有序子链表之后得到的子链表一定也是有序的。
因此可以保证最后得到的链表是有序的。

https://blog.csdn.net/weixin_44178736/article/details/111188252

class Solution {
public:
    ListNode* sortList(ListNode* head) {
        if (head == nullptr) {
            return head;
        }
        int length = 0;
        ListNode* node = head;
        //获取链表长度
        while (node != nullptr) {
            length++;
            node = node->next;
        }
        //生成一个空指针 虚拟头结点 其值为零
        ListNode* dummyHead = new ListNode(0, head);
        //c<<=2 就是 c=c<<2  把c左移2位得到的值给 c   即是subLength×2
        for (int subLength = 1; subLength < length; subLength <<= 1) {
        //前一个节点prev   当前节点curr
            ListNode* prev = dummyHead, *curr = dummyHead->next;
            while (curr != nullptr) 
            {
            
                ListNode* head1 = curr;
                //移到subLength-1个结点 找出一部分子链 长度为subLength结点的子链
                for (int i = 1; i < subLength && curr->next != nullptr; i++)
                 {
                    curr = curr->next;
                }
                //尾结点后面一个点
                ListNode* head2 = curr->next;
                //切断子链
                curr->next = nullptr;
                curr = head2;
                移到第二次的 subLength-1个结点 找出一部分子链 长度为subLength结点的子链
                for (int i = 1; i < subLength && curr != nullptr && curr->next != nullptr; i++) 
                {
                    curr = curr->next;
                }
				
                ListNode* next = nullptr;
                //切断第二个子链表
                if (curr != nullptr)
                 {
                    next = curr->next;
                    curr->next = nullptr;
                }
                ListNode* merged = merge(head1, head2);
                prev->next = merged;//取到合并后的子链
                while (prev->next != nullptr) 
                {
                //指针跳出此链表
                    prev = prev->next;
                }
                //当前指向刚才的curr->next
                curr = next;//然后归并剩下的链表
            }
        }
        return dummyHead->next;
    }

    ListNode* merge(ListNode* head1, ListNode* head2) {
        ListNode* dummyHead = new ListNode(0);
        ListNode* temp = dummyHead, *temp1 = head1, *temp2 = head2;
        while (temp1 != nullptr && temp2 != nullptr) {
            if (temp1->val <= temp2->val) {
                temp->next = temp1;
                temp1 = temp1->next;
            } else {
                temp->next = temp2;
                temp2 = temp2->next;
            }
            temp = temp->next;
        }
        if (temp1 != nullptr) {
            temp->next = temp1;
        } else if (temp2 != nullptr) {
            temp->next = temp2;
        }
        return dummyHead->next;
    }
};