3-106-(LeetCode-23) 合并K个升序链表

1. 题目

 

https://leetcode.cn/problems/merge-k-sorted-lists/

 

考察点

 Leetcode 23 是一个关于合并 k 个有序链表的问题。它考察的是排序、分治和合并排序的知识。

你需要使用一个优先队列或者一个最小堆来维护 k 个链表的当前最小元素，

然后每次从中取出最小的一个，加入到结果链表中，再把它所在的链表的下一个元素放入优先队列或者最小堆中，直到所有的链表都为空为止。

这样可以保证时间复杂度为 O(nlogk)，其中 n 是所有链表的总节点数，k 是链表的个数

2. 解法

有两种解法

• 使用优先队列，也叫最小堆
• 使用分治法

 

使用优先队列，也叫最小堆

思路

• 我想要把k个有序的链表合并成一个有序的链表，那么我需要每次从k个链表中找出最小的节点，加入到结果链表中，直到所有链表都为空。
• 为了方便地找出最小的节点，我想到了使用优先队列这种数据结构，它可以让我快速地取出最小的元素，并且可以动态地更新队列中的元素。
• 我把每个链表的头节点放入优先队列中，然后每次从队列中取出最小的节点，加入到结果链表中，然后把该节点的下一个节点放入队列中，直到队列为空。
• 这样，我就可以保证结果链表是有序的，并且时间复杂度和空间复杂度都比较低。

代码逻辑

代码的逻辑是这样的：

• 首先，判断输入的链表数组是否为空，如果为空，直接返回null。
• 然后，创建一个优先队列，这是一种特殊的数据结构，它可以按照一定的规则（比如节点的值）来排序队列中的元素，并且可以快速地取出最小（或最大）的元素。我们需要传入一个比较器（Comparator）来定义排序的规则，这里我们让节点的值越小，优先级越高。
• 接着，遍历输入的链表数组，把每个链表的头节点（如果不为空）放入优先队列中。这样，队列中就有k个节点，分别是k个链表的第一个节点。
• 然后，创建一个虚拟头节点和一个指针，用来构造结果链表。虚拟头节点是一个没有实际意义的节点，它只是为了方便操作结果链表，它的下一个节点才是真正的结果链表的头节点。指针是用来遍历结果链表的，它始终指向结果链表的最后一个节点。
• 接着，当优先队列不为空时，重复以下操作：
  • 从优先队列中取出最小的节点，这个节点就是当前k个链表中最小的节点。把这个节点加入到结果链表中，也就是让指针的下一个节点指向这个节点，并且更新指针。
  • 如果这个节点有下一个节点，说明它所在的链表还没有遍历完，那么就把它的下一个节点放入优先队列中。这样，队列中又有k个节点，分别是k个链表中当前最小的节点。
• 最后，当优先队列为空时，说明所有链表都遍历完了，结果链表也构造完了。返回虚拟头节点的下一个节点，就是结果链表的头节点。

具体实现

 

?

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28

public ListNode mergeKLists(ListNode[] lists) {     if (lists == null || lists.length == 0) return null;     // 创建一个优先队列，按照节点的值从小到大排序     PriorityQueue<ListNode> queue = new PriorityQueue<>(lists.length, new Comparator<ListNode>() {         @Override         public int compare(ListNode o1, ListNode o2) {             return o1.val - o2.val;         }     });     // 把每个链表的头节点入队     for (ListNode node : lists) {         if (node != null) queue.offer(node);     }     // 创建一个虚拟头节点和一个指针     ListNode dummy = new ListNode(0);     ListNode p = dummy;     // 当队列不为空时，循环操作     while (!queue.isEmpty()) {         // 取出队列中的最小节点，加入到结果链表中         ListNode node = queue.poll();         p.next = node;         p = p.next;         // 如果该节点有下一个节点，把下一个节点入队         if (node.next != null) queue.offer(node.next);     }     // 返回结果链表的头节点     return dummy.next; }

　　

 

 

使用分治法

思路

另一种解法是使用分治法，也就是把k个链表分成两半，然后递归地合并每一半，最后再合并两个已经有序的链表。这样可以减少比较的次数，时间复杂度是O(nlogk)，空间复杂度是O(logk)，其中n是所有链表的节点总数，k是链表的个数。

代码逻辑

以上代码的逻辑是使用分治法来合并k个有序的链表。具体的步骤是：

• 首先，判断输入的链表数组是否为空，如果为空，直接返回null。
• 然后，调用一个辅助函数，传入链表数组和左右边界，表示要合并的链表范围。
• 在辅助函数中，如果左右相等，说明只有一个链表，直接返回该链表；如果左边大于右边，说明没有链表，返回null。
• 然后，计算中间位置，把链表数组分成两半，递归地调用辅助函数来合并每一半的链表，得到两个有序的链表。
• 最后，调用另一个辅助函数，传入两个有序的链表，用一个虚拟头节点和一个指针来构造结果链表。每次比较两个链表的当前节点，取出较小的节点，加入到结果链表中，并且更新指针和链表。如果有一个链表为空，把另一个链表的剩余部分加入到结果链表中。返回虚拟头节点的下一个节点，就是结果链表的头节点。

具体实现

?

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44

public ListNode mergeKLists(ListNode[] lists) {     if (lists == null || lists.length == 0) return null;     return merge(lists, 0, lists.length - 1); }   // 分治法，把k个链表分成两半，递归地合并每一半，最后再合并两个有序的链表 private ListNode merge(ListNode[] lists, int left, int right) {     // 如果左右相等，说明只有一个链表，直接返回     if (left == right) return lists[left];     // 如果左边大于右边，说明没有链表，返回null     if (left > right) return null;     // 计算中间位置     int mid = left + (right - left) / 2;     // 递归地合并左半部分的链表     ListNode l1 = merge(lists, left, mid);     // 递归地合并右半部分的链表     ListNode l2 = merge(lists, mid + 1, right);     // 合并两个有序的链表     return mergeTwoLists(l1, l2); }   // 合并两个有序的链表 private ListNode mergeTwoLists(ListNode l1, ListNode l2) {     // 创建一个虚拟头节点和一个指针     ListNode dummy = new ListNode(0);     ListNode p = dummy;     // 当两个链表都不为空时，循环操作     while (l1 != null && l2 != null) {         // 比较两个链表的当前节点，取出较小的节点，加入到结果链表中         if (l1.val < l2.val) {             p.next = l1;             l1 = l1.next;         } else {             p.next = l2;             l2 = l2.next;         }         p = p.next;     }     // 如果有一个链表为空，把另一个链表的剩余部分加入到结果链表中     if (l1 != null) p.next = l1;     if (l2 != null) p.next = l2;     // 返回结果链表的头节点     return dummy.next; }

　

 

两种解法对比

这个问题没有一个确定的答案，不同的解法有不同的优缺点。在这个情况下，一个人可能会说：

• 如果k很大，那么优先队列的解法可能更好，因为它可以减少空间复杂度，只需要存储k个节点，而不是logk层递归调用的栈空间。
• 如果k很小，那么分治法的解法可能更好，因为它可以减少时间复杂度，只需要比较nlogk次，而不是nlogk*k次。
• 如果链表的长度不均匀，那么分治法的解法可能更好，因为它可以平衡地合并链表，而不是每次都从最长的链表中取出节点。
• 如果链表的长度比较均匀，那么优先队列的解法可能更好，因为它可以避免多余的比较，只需要比较队列中的k个节点。

所以，最好的解法取决于具体的情况和需求。你可以根据你的偏好和判断来选择合适的解法

　

3. 总结