[leetcode] 23. 合并 K 个升序链表

会飞的大鱼人

已于 2024-03-07 17:31:51 修改

阅读量1.1k

点赞数 26

分类专栏： leetcode题解文章标签：链表数据结构 leetcode 算法 java

于 2024-02-04 12:19:41 首次发布

本文链接：https://blog.csdn.net/lvhao123456789/article/details/136021196

版权

leetcode题解专栏收录该内容

68 篇文章 0 订阅

订阅专栏

文章目录

题目描述
解题方法
相似题目

题目描述

给你一个链表数组，每个链表都已经按升序排列。
请你将所有链表合并到一个升序链表中，返回合并后的链表。

示例 1：

输入：lists = [[1,4,5],[1,3,4],[2,6]]
输出：[1,1,2,3,4,4,5,6]
解释：链表数组如下：
[
  1->4->5,
  1->3->4,
  2->6
]
将它们合并到一个有序链表中得到。
1->1->2->3->4->4->5->6

示例 2：

输入：lists = []
输出：[]

示例 3：

输入：lists = [[]]
输出：[]

提示：

k == lists.length
0 <= k <= 10⁴
0 <= lists[i].length <= 500
-10⁴ <= lists[i][j] <= 10⁴
lists[i] 按升序排列
lists[i].length 的总和不超过 10⁴

解题方法

方法一：顺序合并

此方法需要掌握合并两个升序链表的方法。没掌握的童鞋可以先看这篇[leetcode] 21. 合并两个有序链表。
我们用一个head链表代表当前合并链表，初始为空。每次合并时，我们将head链表与第i个链表合并。链表数组遍历完成时，head链表即为最终结果。

java代码

ListNode结构

public class ListNode {
    public int val;
    public ListNode next;

    public ListNode() {
    }

    public ListNode(int val) {
        this.val = val;
    }

    public ListNode(int val, ListNode next) {
        this.val = val;
        this.next = next;
    }
}

合并方法

public ListNode mergeKLists(ListNode[] lists) {
    ListNode head = null;
    for(int i = 0; i < lists.length; i++) {
        head = mergeTwoLists(head, lists[i]);
    }
    return head;
}

public ListNode mergeTwoLists(ListNode list1, ListNode list2) {
    ListNode dummyNode = new ListNode(0, null);
    ListNode p = dummyNode;
    ListNode l1 = list1;
    ListNode l2 = list2;
    while (l1 != null && l2 != null) {
        if (l1.val <= l2.val) {
            p.next = l1;
            p = p.next;
            l1 = l1.next;
        } else {
            p.next = l2;
            p = p.next;
            l2 = l2.next;
        }
    }
    if (l1 != null) {
        p.next = l1;
    } else {
        p.next = l2;
    }
    return dummyNode.next;
}

复杂度分析

时间复杂度：假设每个链表的最长长度是 $n$ 。在第一次合并后， $h e a d$ 的长度为 $n$ ；第二次合并后， $h e a d$ 的长度为 $\times n$ ，第 $i$ 次合并后， $h e a d$ 的长度为 $\times n$ 。第 $i$ 次合并的时间代价是 $\times n)$ ，那么总的时间代价为 $O(\sum_{i=1}^k(i \times n)) = O(\frac{(1+k)⋅k} {2} \times n)=O(k^2n)$ ，故渐进时间复杂度为 $O(k^2n)$ 。
空间复杂度：只有指针遍历，没有用到与 $k$ 和 $n$ 规模相关的辅助空间，故渐进空间复杂度为 $O (1)$ 。

方法二：使用小根堆合并

我们首先将每个链表的头指针添加到小根堆中，此时小根堆中顶部的元素即为所有链表头部最小的元素。第一步，小根堆头部元素出栈，出栈的结点加入到结果链表尾部。第二步，再将出栈结点的下一个结点加入到小根堆中（没有下一个结点则不需要加入），此时小根堆中的顶部元素即为所有链表当前头部的最小元素。然后按照上面的第一步和第二步重复操作，直到小根堆为空，此时得到升序后的结果链表。

java代码

import java.util.PriorityQueue;

public class Solution {
    class Status implements Comparable<Status> {
        public ListNode node;

        public Status(ListNode node) {
            this.node = node;
        }

        @Override
        public int compareTo(Status status) {
            return this.node.val - status.node.val;
        }
    }

    public ListNode mergeKLists(ListNode[] lists) {
        ListNode dummyNode = new ListNode(0, null);
        ListNode curNode = dummyNode;
        PriorityQueue<Status> minHeap = new PriorityQueue<>();
        for (ListNode node : lists) {
            if (node != null) {
                minHeap.offer(new Status(node));
            }
        }
        while (!minHeap.isEmpty()) {
            Status status = minHeap.poll();
            curNode.next = status.node;
            curNode = status.node;
            if (status.node.next != null) {
                minHeap.offer(new Status(status.node.next));
            }
        }
        return dummyNode.next;
    }
}

复杂度分析

时间复杂度：假设有 $k$ 个链表，则小根堆中的元素不超过 $k$ ，则每次插入和删除元素的时间复杂度为 $O (l o g k)$ 。设每个链表最长长度为 $n$ ，则总的渐进时间复杂度为 $\times logk)$ 。
空间复杂度：最多有 $k$ 个元素存储在小根堆中，故空间复杂度为 $O (k)$ 。