[LeetCode刷题笔记] 148.排序链表

学习自用

链接

148.排序链表

思路

1. 归并排序（递归法）
   对单链表排序首先想到归并排序（因为无法回访前驱节点，快排等算法无法使用，而归并排序的合并操作，单链表可以很好地完成。）
   递归法步骤：
   1. 快慢指针法找到中间节点。
   2. 断链，并得到右侧链表头
   3. 递归排序左右链表
   4. 合并

/**
 * 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) {
        return merge_sort(head);
    }


    ListNode* merge_sort(ListNode* head) {
        if(head == nullptr || head->next == nullptr) return head;
        //快慢指针找中点
        ListNode* fast = head->next;
        ListNode* slow = head;
        while(fast && fast->next) {
            fast = fast->next->next;
            slow = slow->next;
        }
        ListNode* l1 = head;
        ListNode* l2 = slow->next;
        slow->next = nullptr;
        l1 = merge_sort(l1);
        l2 = merge_sort(l2);
        ListNode newhead;
        ListNode* rear = &newhead;
        while(l1 && l2) {
            if(l1->val <= l2->val) {
                rear->next = l1;
                rear = rear->next;
                l1 = l1->next;
            }
            else {
                rear->next = l2;
                rear = rear->next;
                l2 = l2->next;
            }
        }
        rear->next = l1 ? l1 : l2;

        return newhead.next;
    }
};

2. 归并排序（迭代法）
   由于题目要求使用常数级空间，递归法会消耗栈空间，为O(logn)。所以本题应使用迭代法求解。
   迭代法基本思想与递归法一致，有几个需要注意的点
   1. 自底向上合并，所以每轮合并长度小于等于i的两个链表，i为1,2,4…，直至i > 整个链表长度，代表合并结束。
   2. cut操作（重点），切下给定头节点的前n个节点，并返回后半部分的头节点，不足返回nullptr。
   3. 无需判断l2是否为空是否特殊处理，merge操作即可处理，cur为空的话，下一个循环就会退出。

cut部分代码

ListNode* cut(ListNode* p, int n) {
    //--n可使p在循环结束时指向l2的前驱节点
    while(--n && p) {
        p = p->next;
    }
    if(p == nullptr) return nullptr;
    //后半部分的头节点
    ListNode* res = p->next;
    //断链
    p->next = nullptr;
    return res;
}

步骤：

1. 计算链表长度
2. 按照本次循环处理的子链表长度对链表进行切分，每两个一组，之后合并，由于是自底向上的，子链表均有序。

/**
 * 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* cut(ListNode* p, int n) {
        //--n可使p指向l2的前驱节点
        while(--n && p) {
            p = p->next;
        }
        if(p == nullptr) return nullptr;
        ListNode* res = p->next;
        p->next = nullptr;
        return res;
    }

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

    ListNode* sortList(ListNode* head) {
        //求链表长度
        ListNode* p = head;
        int len = 0;
        while(p) {
            p = p->next;
            len++;
        }
        if(len == 0) return nullptr;

        //建立头节点
        ListNode res;
        res.next = head;

        //迭代式归并排序
        for(int size = 1; size <= len; size *= 2) {
        	//长度改变，重新指向链表头
            ListNode* pre = &res;
            ListNode* cur = pre->next;
            while(cur) {
                ListNode* l1 = cur;
                ListNode* l2 = cut(l1, size);
                cur = cut(l2, size);
                pre->next = merge(l1, l2);
                while(pre->next)
                    pre = pre->next;
            }
        }

        return res.next;
    }
};