【LeetCode】148. 排序链表

148. 排序链表(中等)

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

方法一:归并排序(递归法)

思路

  • 题目要求时间空间复杂度分别为 O(nlogn) 和 O(1) ,根据时间复杂度我们自然想到二分法,从而联想到归并排序

  • 对数组做归并排序的空间复杂度为 O(n) ,分别由新开辟数组 O(n) 和递归函数调用 O(logn) 组成,而根据链表特性:

    • 数组额外空间:链表可以通过修改引用来更改节点顺序,无需像数组一样开辟额外空间;
    • 递归额外空间:递归调用函数将带来 O(logn) 的空间复杂度,因此若希望达到 O(1) 空间复杂度,则不能使用递归。
  • 通过递归实现链表归并排序,有以下两个环节:

    • 分割 cut 环节: 找到当前链表 中点,并从中点将链表断开(以便在下次递归 cut 时,链表片段拥有正确边界);
      • 我们使用 fast,slow 快慢双指针法,「奇数个节点找到中点,偶数个节点找到中心左边的节点」。
      • 找到中点 slow 后,执行 slow->next = nullptr; 将链表切断。
      • 递归分割时,输入当前链表左端点 head 和中心节点 slow 的下一个节点 tmp(因为链表是从 slow 切断的)。
      • cut 递归终止条件: 当 head->next == nullptr 时,说明只有一个节点了,直接返回此节点。
    • 合并 merge 环节: 将两个排序链表合并,转化为一个排序链表。
      • 双指针法合并,建立辅助 ListNode* h 作为头部。
      • 设置两指针 left, right 分别指向两链表头部,比较两指针处节点值大小,由小到大加入合并链表头部,指针交替前进,直至添加完两个链表。
        返回辅助ListNode* h 作为头部的下个节点 h->next
      • 时间复杂度 O(l + r),l, r 分别代表两个链表长度。
    • 当题目输入的 head == nullptr 时,直接返回 None。

【LeetCode】148. 排序链表_第1张图片

代码

/**
 * 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 (head == nullptr || head->next == nullptr) {
            return head;
        }
        // 定义快慢指针找到分割中点 slow
        ListNode* fast = head->next;
        ListNode* slow = head;
        while(fast && fast->next) {
            slow = slow->next;
            fast = fast->next->next;
        }
        // 右半边的头节点 tmp
        ListNode* tmp = slow->next;
        // 左右分割
        slow->next = nullptr;
        // 递归分割
        ListNode* left = sortList(head);
        ListNode* right = sortList(tmp);

        // 定义辅助头节点 h
        ListNode* h = new ListNode(0);
        ListNode* res = h; // res保存h的头节点

        // 合并
        while (left && right) {
            if (left->val < right->val) {
                h->next = left;
                left = left->next;
            }
            else {
                h->next = right;
                right = right->next;
            }
            h = h->next;
        }
        // 检查是left为空还是right为空
        h->next = left != nullptr ? left : right;
        return res->next;
    }
};

方法二:归并排序(从底至顶直接合并)

思路

  • 对于非递归的归并排序,需要使用迭代的方式替换 cut 环节:

    • cut 环节本质上是通过二分法得到链表最小节点单元,再通过多轮合并得到排序结果。
    • 每一轮合并 merge 操作针对的单元都有固定长度 intv,例如:
      • 第一轮合并时 intv = 1,即将整个链表切分为多个长度为 1 的单元,并按顺序两两排序合并,合并完成的已排序单元长度为 2。
      • 第二轮合并时 intv = 2,即将整个链表切分为多个长度为 2 的单元,并按顺序两两排序合并,合并完成已排序单元长度为 4。
      • 以此类推,直到单元长度 intv >= 链表长度,代表已经排序完成。
    • 根据以上推论,我们可以仅根据 intv 计算每个单元边界,并完成链表的每轮排序合并,例如:
      • 当 intv = 1 时,将链表第 1 和第 2 节点排序合并,第 3 和第 4 节点排序合并,……。
      • 当 intv = 2 时,将链表第 1-2 和第 3-4 节点排序合并,第 5-6 和第 7-8 节点排序合并,……。
      • 当 intv = 4 时,将链表第 1-4 和第 5-8 节点排序合并,第 9-12 和第 13-16 节点排序合并,……。
  • 此方法时间复杂度 O(nlogn) ,空间复杂度 O(1) 。

【LeetCode】148. 排序链表_第2张图片

  • 模拟上述的多轮排序合并:

    • 统计链表长度 length,用于通过判断 intv < length 判定是否完成排序;
    • 额外声明一个节点 res,作为头部后面接整个链表,用于:
      • intv *= 2 即切换到下一轮合并时,可通过 res->next 找到链表头部 h;
      • 执行排序合并时,需要一个辅助节点作为头部,而 res 则作为链表头部排序合并时的辅助头部 pre;后面的合并排序可以将上次合并排序的尾部 tail 用做辅助节点。
    • 在每轮 intv 下的合并流程:
      • 根据 intv 找到合并单元 1 和单元 2 的头部 h1, h2。由于链表长度可能不是 2^n,需要考虑边界条件
        • 在找 h2 过程中,如果链表剩余元素个数少于 intv,则无需合并环节,直接 break,执行下一轮合并;
        • 若 h2 存在,但以 h2 为头部的剩余元素个数少于 intv,也执行合并环节,h2 单元的长度为 c2 = intv - i。
      • 合并长度为 c1, c2 的 h1, h2 链表,其中:
        • 合并完后,需要修改新的合并单元的尾部 pre 指针指向下一个合并单元头部 h。(在寻找 h1, h2 环节中,h指针已经被移动到下一个单元头部
        • 合并单元尾部同时也作为下次合并的辅助头部 pre。
      • 当 h == None,代表此轮 intv 合并完成,跳出。
    • 每轮合并完成后将单元长度 ×2,切换到下轮合并:intv *= 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* sortList(ListNode* head) {
        if (head == nullptr || head->next == nullptr) return head;
        int intv = 1, length = 0;
        // res保存已排序的结果链表头节点
        ListNode* res = new ListNode(0);
        res->next = head;
        // pre指向已排序的结果链表的末尾
        // h指向待排序链表的头节点
        ListNode* pre;
        ListNode* h;
        // 遍历链表,得到长度
        while (head) {
            length ++;
            head = head->next;
        }
        while (intv < length) {
            pre = res;
            h = res->next;
            // 当待排序链表头节点不为空,说明还需要归并
            while(h) {
                // tmp1保存合并单元1的头节点
                ListNode* tmp1 = h;
                int len1 = intv;
                while (len1 > 0 && h) {
                    len1 --;
                    h = h->next;
                } 
                if(len1 > 0) {
                    break;
                }
                // tmp2保存合并单元2的头节点
                ListNode* tmp2 = h;
                int len2 = intv; 
                while (len2 > 0 && h) {
                    len2 --;
                    h = h->next;
                }
                // c1 c2分别是合并单元剩余的节点(即合并单元各自的节点数)
                int c1 = intv, c2 = intv - len2;
                while (c1 > 0 && c2 > 0) {
                    if (tmp1->val > tmp2->val) {
                        pre->next = tmp2;
                        tmp2 = tmp2->next;
                        c2 --; // 减少一个节点
                    }
                    else {
                        pre->next = tmp1;
                        tmp1 = tmp1->next;
                        c1--;
                    }
                    pre = pre->next;
                }
                // 将c1剩余节点连接到已排序节点的末尾
                if(c1 > 0) {
                    pre->next = tmp1;
                }
                else {
                    pre->next = tmp2;
                }
                // 更新pre 使其指向已排序链表的末尾
                while (c1-- > 0 || c2-- > 0) {
                    pre = pre->next;
                }
                // 将已排序链表和待排序链表连接
                pre->next = h;
            }
            intv *= 2;
        }
        return res->next;
    }
};

参考资料

  1. Sort List (归并排序链表)

你可能感兴趣的:(LeetCode刷题,leetcode,链表,算法)