归并排序-leetcode148

1. 因为链表中节点的顺序要打乱，所以要使用一个假头

2. 计算链表的长度，按不同节点个数对链表进行分组排序

3. 每次分组排序，都需要遍历整个链表，拆分节点、合并

1. 需要一个pcur指针和一个tail指针

2. pcur指针用于指向原链表，通过pcur来遍历原来的链表

3. tail指针用来连接分组排序后的节点

4. 需要一个cut函数和一个merge函数

1. cut用于将链表进行切分，切分出不同个数的节点

2. merge用于将切分出来的节点组，两两进行合并排序

代码如下：

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution {
public:
    ListNode* sortList(ListNode* head) {
        // 归并排序
        if(nullptr==head) return nullptr;
        ListNode* cur = head;
        int len = 0;
        while(cur!=nullptr) {
            len++;
            cur = cur->next;
        }

        ListNode dummy(-1);
        dummy.next = head;

        for(int size = 1; size < len; size<<=1) {
            cur = dummy.next;  // ！！这里要指向dummy的下一个节点，不能指向head，因为head不一定是dummy的下一个节点 排序节点顺序变了
            auto tail = &dummy; // 用来连接 在每一层
            while(cur!=nullptr) {
                auto left = cur;
                auto right = cut(left, size);
                cur = cut(right, size);
                tail->next = merge(left, right);
                while(tail->next) {
                    tail = tail->next;
                }
            }
        }
        return dummy.next;
    }

    ListNode* cut(ListNode* head, int size) {
        // head用来返回cut下来的，返回值是剩下的链表
        auto pcur = head;
        while(pcur && --size) {
            pcur = pcur->next;
        }
        if (pcur==nullptr) return nullptr;
        auto ret = pcur->next;
        pcur->next = nullptr;
        return ret;
    }

    ListNode* merge(ListNode* l1, ListNode* l2) {
        ListNode dummy(-1);
        ListNode* pcur = &dummy;
        while(l1 && l2) {
            if(l1->val < l2->val) {
                pcur->next = l1;
                l1 = l1->next;
            } else {
                pcur->next = l2;
                l2 = l2->next;
            }
            pcur = pcur->next;
        }
        pcur->next = l1?l1:l2;
        return dummy.next;
    }
};