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

题目描述

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

示例 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$。在第一次合并后，$head$的长度为 $n$；第二次合并后，$head$的长度为 $2\times n$，第 $i$次合并后，$head$ 的长度为 $i\times n$。第$i$次合并的时间代价是 $O(i\times n)$，那么总的时间代价为 $O({\sum }_{i=1}^k(i\times n))=O(\frac{(1+k)\cdot k}{2}\times n)=O(k^{2}n)$，故渐进时间复杂度为 $O(k^{2}n)$。
空间复杂度：只有指针遍历，没有用到与 $k$ 和 $n$ 规模相关的辅助空间，故渐进空间复杂度为 $O(1)$。

方法二：使用小根堆合并

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

java代码

import java.util.PriorityQueue;

public class Solution {
    class Status implements Comparable {
        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 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(logk)$。设每个链表最长长度为$n$，则总的渐进时间复杂度为$O(kn\times logk)$。
空间复杂度：最多有$k$个元素存储在小根堆中，故空间复杂度为$O(k)$。

相似题目

[leetcode] 21. 合并两个有序链表

---

• 个人公众号
  
• 个人小游戏