Sort List

Sun, 01 Dec 2024 00:00:00 +0000

148. 排序链表

分析

计算链表长度
- 遍历链表，统计节点数量 n，以确定归并的步长范围
自底向上归并排序
- 按步长 i 从小到大逐步归并，初始步长为 1，逐渐乘以 2，直到覆盖整个链表
- 每次归并时，将链表分成两部分，每部分包含 i 个节点，然后对这两部分进行归并
- 最后将归并的结果重新连接到链表中
归并两个子链表
- 使用两个指针分别指向两个子链表的头部，逐一比较节点的值，将较小值的节点加入到排序后的链表中，直到处理完两部分中的所有节点
更新链表
- 经过多轮归并后，最终的链表即为排序后的链表

时间复杂度

每轮归并的时间复杂度为 O(n)，需要进行 log(n) 轮归并，因此总复杂度为 O(nlogn)

空间复杂度

采用自底向上归并，不需要额外空间，空间复杂度为 O(1)

C++代码

class Solution
{
public:
    ListNode* sortList(ListNode* head)
    {
        // 第 1 步：计算链表长度
        int n = 0;
        for (ListNode* p = head; p; p = p->next)
            ++n;

        // 第 2 步：归并排序
        for (int i = 1; i < n; i *= 2)
        {
            ListNode* dummy = new ListNode(-1); // 虚拟头节点
            ListNode* cur = dummy;

            for (int j = 1; j <= n; j += i * 2)
            {
                // 划分两段链表
                ListNode *p = head, *q = p;
                for (int k = 0; k < i && q; ++k)
                    q = q->next; // 第二段起点

                ListNode* o = q;
                for (int k = 0; k < i && o; ++k)
                    o = o->next; // 下一部分的起点

                // 归并两段链表
                int l = 0, r = 0;
                while (l < i && r < i && p && q)
                {
                    if (p->val <= q->val)
                    {
                        cur->next = p;
                        p = p->next;
                        ++l;
                    }
                    else
                    {
                        cur->next = q;
                        q = q->next;
                        ++r;
                    }
                    cur = cur->next;
                }

                // 剩余部分处理
                while (l < i && p)
                {
                    cur = cur->next = p;
                    p = p->next;
                    ++l;
                }

                while (r < i && q)
                {
                    cur = cur->next = q;
                    q = q->next;
                    ++r;
                }

                // 更新链表头
                head = o;
            }
            cur->next = nullptr;
            head = dummy->next; // 更新链表头为新的排序结果
        }

        return head;
    }
};

Merge k Sorted Lists

Mon, 25 Mar 2024 00:00:00 +0000

23. 合并K个升序链表

分析

使用优先队列
- 创建一个优先队列 heap，用于存储链表节点
- 队列中的元素按节点值从小到大排序（小根堆）
- 使用一个自定义比较器 cmp 来实现小根堆的逻辑
初始化优先队列
- 将所有链表的头节点（如果非空）加入优先队列
归并链表
- 每次从优先队列中取出值最小的节点 temp，将其加入新链表
- 如果 temp 节点还有下一个节点，则将其 next 节点加入优先队列
- 重复以上步骤，直到队列为空

时间复杂度

优先队列的插入和删除操作的时间复杂度为 O(logk)，其中 k 是链表的数量
每个节点都会被插入和删除一次，因此总时间复杂度为 O(nlogk)，其中 n 是链表中所有节点的总数

空间复杂度

优先队列最多同时存储 k 个节点，因此空间复杂度为 O(k)

C++代码

class Solution
{
public:
    ListNode* mergeKLists(vector<ListNode*>& lists)
    {
        // 自定义比较器，用于优先队列排序
        struct cmp
        {
            bool operator()(ListNode* a, ListNode* b)
            {
                return a->val > b->val; // 小根堆
            }
        };

        // 定义优先队列（小根堆）
        std::priority_queue<ListNode*, std::vector<ListNode*>, cmp> heap;

        // 初始化优先队列，将每个链表的头节点加入堆中
        for (ListNode* li : lists)
            if (li)
                heap.push(li);

        // 定义虚拟头节点，便于操作新链表
        ListNode* dummy = new ListNode(-1);
        ListNode* cur = dummy;

        // 从优先队列中逐步取出最小值节点，并更新链表
        while (!heap.empty())
        {
            ListNode* temp = heap.top(); // 获取当前最小值节点
            heap.pop();                  // 将其从堆中移除
            cur = cur->next = temp;      // 将其加入新链表
            if (temp->next)              // 如果有后续节点，将后续节点加入堆中
            {
                temp = temp->next;
                heap.push(temp);
            }
        }

        // 返回合并后的链表
        return dummy->next;
    }
};

Merge Sort on Hang Zhang

Sort List

148. 排序链表

分析

时间复杂度

空间复杂度

C++代码

Merge k Sorted Lists

23. 合并K个升序链表

分析

时间复杂度

空间复杂度

C++代码