力扣23.合并K个升序链表

文章目录

  • 一、前言
  • 二、最小堆解法
  • 三、分治解法

一、前言

23. 合并 K 个升序链表

本题的要求是把K个链表进行合并,合并后的链表必须是从小到大的。

并且这K个链表也是从小到大的升序链表。


二、最小堆解法

既然每个链表都是升序的,也就是从小到大的。

那么最后合并出来的链表的第一个节点,也肯定是K个链表的某个链表(记做first链表)第一个节点的其中一个。

合并之后的第二个节点,可以是其余链表的第一个节点或是first链表的第二个节点。

抓住这个规律,我们只需要每次收集每个链表的第一个节点,然后进行排序,取最小那个节点进行合并即可。

如果某个链表的第一个节点已经合并了,那么取第二个。如果第二个也合并了,那么取第三个。以此类推!

这里的话就可以考虑使用最小堆来完成这个排序工作,只需要把节点入堆,然后弹出堆中的最小堆即可。

思路如下:

  1. 初始化堆,将K个链表的第一个节点入堆
  2. 不断弹出最小堆,直到堆为空为止
    • 对弹出的节点进行合并,如果弹出节点的next不为空,继续将节点的next入堆
java 复制代码
public ListNode mergeKLists(ListNode[] lists) {
    PriorityQueue<ListNode> queue = new PriorityQueue<>((o1, o2) -> o1.val - o2.val);
    for (ListNode head : lists) {
        if (head != null){
            queue.add(head);
        }
    }

    ListNode head = new ListNode();
    ListNode p0 = head;
    while (!queue.isEmpty()){
        ListNode node = queue.poll();
        p0.next = node;
        p0 = p0.next;
        if (node.next != null){
            queue.add(node.next);
        }
    }
    return head.next;
}
  • 时间复杂度: O(nlog⁡k),其中n为链表总数,k为链表的数量。前面初始化堆的时间复杂度为O(k),合并链表的时候,从堆中取出最小堆的时间复杂度O(logk),链表总数为n,链表的所有节点都会放进堆中,因此从堆中取最小堆这个操作需要执行n次,因此时间复杂度为O(nlog⁡k)
  • 空间复杂度:O(k),堆中最多存放k个元素。

三、分治解法

分治的思路就是将一个问题拆分成多个子问题,最后将所有子问题进行合并,从而解决问题。

于是我们可以将k个链表分成两个部分,分别为前半部分链表和后半部分链表,先分别对前半部分链表和后半部分链表进行合并成两个升序的链表,然后对升序的两个链表进行合并。

要对前半部分链表和后半部分链表分别合并成两个升序链表,可以继续对这两部分链表进行拆分,一分为二,直到只有一个链表,那就不需要合并了。

因此需要用递归了解决问题

java 复制代码
public ListNode mergeKLists(ListNode[] lists) {
    return mergeKLists(lists, 0, lists.length);
}

private ListNode mergeKLists(ListNode[] lists, int i, int j) {
    int m = j - i;
    if (m == 0) {
        return null;
    }
    if (m == 1) {
        return lists[i];
    }
    ListNode left = mergeKLists(lists, i, i + m / 2);
    ListNode right = mergeKLists(lists, i + m / 2, j);
    return mergeKTwoLists(left, right);
}

private ListNode mergeKTwoLists(ListNode left, ListNode right) {
    ListNode head = new ListNode(-1, null);
    ListNode p0 = head;
    while (left != null && right != null) {
        if (left.val > right.val) {
            p0.next = right;
            right = right.next;
        } else {
            p0.next = left;
            left = left.next;
        }
        p0 = p0.next;
    }
    if (left != null){
        p0.next = left;
    }
    if (right != null){
        p0.next = right;
    }
    return head.next;
}
  • 时间复杂度:O(nlogk)。n为链表总数,k为链表数量。分治的时间复杂度为O(logk),每个节点都要参与一次合并,那么就是O(nlogk).
  • 空间复杂度:O(logk)。递归深度为 O(logk),需要用到 O(logk) 的栈空间。
相关推荐
我星期八休息1 天前
深入理解跳表(Skip List):原理、实现与应用
开发语言·数据结构·人工智能·python·算法·list
lingran__1 天前
速通ACM省铜第四天 赋源码(G-C-D, Unlucky!)
c++·算法
送秋三十五1 天前
spring源码分析————ListableBeanFactory
java·后端·spring
努力也学不会java1 天前
【设计模式】状态模式
java·设计模式·状态模式
.豆鲨包1 天前
【设计模式】单例模式
java·单例模式·设计模式
邂逅星河浪漫1 天前
【Docker+Nginx+Ollama】前后端分离式项目部署(传统打包方式)
java·nginx·docker·部署
IAtlantiscsdn1 天前
Redis Stack扩展功能
java·数据库·redis
haogexiaole1 天前
贪心算法python
算法·贪心算法
希望20171 天前
图论基础知识
算法·图论
yunmi_1 天前
2024版 IDEA 用 Maven 创建 java 项目(+Maven 安装和配置)
java·maven