【一文解决】合并K个升序链表（K个升序链表的题都会了，两个链表的题还能不会？）（来源：力扣腾讯精选50题）

嗨小伙伴们好久不见，最近做题了吗？？

今天我又发现了一道挺有意思的题，一起来看看吧！~

题目描述

首先看到的是亮眼的红色“困难”俩字，是什么样的题目竟然能够达到困难的难度？
难道它很难吗？不！不就是链表嘛，链表的问题能难到哪里去呢？_{（表面镇定，内心紧张）}

虽然题目上来就标了困难的难度，但是咱们不慌，相信看完解答你就知道这道题其实一点都不难！废话不多说，先点个一键三连活动下手指，咱们立即开始今天的题解之路！~

复述题目：

有一个链表数组，数组中的每个链表都已经排好序了，现在让你把链表数组中是所有链表都合并到一起，返回合并后的链表。

下面看看给出的示例：

第一个示例，和题目意思一样。

示例2说明数组的大小可能为0。

示例3说明，数组中的链表可能为空链表。

然后我们再看看给出的代码：

右侧代码区只需要提交核心代码，给出了链表节点的结构，是我们熟悉的ListNode。方法返回值也是ListNode，说明我们需要将合并后的链表的头结点返回。

提示和示例中给出的差不多，数组的长度可能为0，链表的长度也可能为0，顺序是升序。

思路分析

看完了前面给出的描述和提示，首先想到的第一个思路应该是两两合并。

思路1：将前面两个链表合并，然后再将合并的链表与下一个链表合并，直到全部合并。

但是这样的做法未免太过低效，有没有高效一点的方法呢？？
有也是有的，那就是分治。

思路2：分而治之
将数组中的链表两两分组，分别合并之后，链表数量减半，再次两两分分组，分别合并，直到最后合并成一个链表。

上面这两个做法的都建立在对两个升序链表进行合并的基础上，所以我们首先我们得会对两个升序链表进行合并。即写一个合并两个链表的方法。

那有没有不用对两个链表进行合并的方法呢？
当然有。
把每个链表的节点都放到一起比较，取最小的那个作为合并链表的下一个节点，然后再将当前最小链表的下一个节点加入比较的行列里。

其实这与将两个链表合并的本质逻辑仍然是一样的，不一样的是我们可以通过一个优先级队列来完成这个事情。

思路3：即用一个小堆进行排序，这样只要将每个链表的当前头结点扔到堆中，这样堆就会给我们直接给我们排出一个最小的节点，我们只需要对结果进行连接就可以了。

下面我们先从较为简单的开始！

思路3 解法

思路3底层需要我们会链表的尾插法：就是给你一个节点，你要一个一个地把它连在后面。为了方便，我们使用一个傀儡头结点head来作为链表的头部，这样后面拿到的节点只要连接到head后面就可以了。

上代码：
Java：

public ListNode mergeKLists1(ListNode[] lists) {
        PriorityQueue<ListNode> queue = new PriorityQueue<>(new Comparator<ListNode>() {
            @Override//这里注意要使用comparator告诉queue节点之间的比较方法
            public int compare(ListNode o1, ListNode o2) {
                return o1.val - o2.val;//按照节点的大小值进行比较
            }
        });
        for (ListNode l : lists) {
            if (l != null) queue.offer(l);//入队
        }
        ListNode head = new ListNode(-1);//建立傀儡头结点
        ListNode cur = head;//使用cur维护链表的最后一个节点
        while (!queue.isEmpty()){//当链表不为空时，说明还有节点需要合并
            ListNode tmp = queue.poll();//取出当前没有合并完的链表中的最小节点
            cur.next = tmp;//连接节点
            cur = cur.next;
            if (tmp.next != null) queue.offer(tmp.next);//当该节点后面还有节点时记得入队
        }
        return head.next;//最后返回傀儡头结点的下一个阶段
    }

思路2 解法

这里主要解决一个问题：两个升序的链表如何合并？

懂得了这个，相信大家也就会另外一道经典题目：合并两个升序链表了~

如果会这个的同学，可以直接跳过这部分直接看代码了。

这个的解法我们就借用上面这两个链表的图（有改动）吧~



下面先给出两两合并的代码：

public ListNode mergeTwoLists(ListNode list1, ListNode list2) {
        ListNode head = new ListNode(-1);//创建傀儡头结点
        ListNode cur = head;//用于维护链表最后一个节点
        while (list1 != null && list2 != null){//循环比较的条件
        	//当list1的值较小时
            while (list1 != null && list2 != null && list1.val < list2.val){//这里可以用while减少外层循环的次数，但是记得要加上外层循环的条件，避免空指针访问
                cur.next = list1;
                cur = cur.next;//cur向后走一步（保持在链表的尾部）
                list1 = list1.next;//(list1向后走一步)
            }
            //当list2的值较小时
            while (list2 != null && list1 != null && list2.val <= list1.val){
                cur.next = list2;
                cur = cur.next;
                list2 = list2.next;
            }
        }
        if (list1 != null){//list2 已经为空，只需将list1剩下的节点连接到链表中即可
            cur.next = list1;//只需将list1的当前头结点连接到cur后面即可
        }else if (list2 != null){
            cur.next = list2;
        }
        return head.next;//返回傀儡头结点的next
    }

通过上图可以得出递归需要start和end两个初始值，通过去start和end获得中间值mid，再以mid作为分界点将数组分为两部分，每部分又分别进入一个新的递归。

当递归到start==end时递归结束。（递归条件）
这里需要思考：存在start > end 的情况吗？
当数组不为空时，是不存在的，但是当数组为空时，start = 0， end = 0 - 1 = -1；
这时候start > end。所以这个情况不能忽略，这时候return null；

下面上代码！！

//递归进行分治
public ListNode merge(ListNode[] lists, int start, int end){
        if (start == end) return lists[start];//数组中只剩一个链表时
        if (start > end) return null;//数组为空的情况
        int mid = (start + end) >> 1;
        //递归到最后每个递归中只有1个链表，将连个链表进行合并，合并返回的链表又与另外一边合并返回的链表进行合并，最后合并成为一个链表。
        return mergeTwoLists(merge(lists,start,mid),merge(lists, mid + 1, end));=
    }

    //解法二 分治法
    public ListNode mergeKLists2(ListNode[] lists) {
       return merge(lists,0,lists.length-1);//调用递归法进行分治合并
    }

分治除了用递归完成，还可以将递归改成循环：
这次先上代码：
_{（光看代码太抽象不太好理解，为了便于理解，我在后面画了图）}

//*循环*代替递归的分治法
    public ListNode mergeKLists(ListNode[] lists) {
        if (lists.length == 0) return null;
        for (int i = 1; i < lists.length; i *= 2) {//步长 两两合并的单个链表的步长
            for (int j = i; j < lists.length; j += i*2) {//往前i步的合并，下一次到两倍步长
                lists[j-i] = mergeTwoLists(lists[j-i],lists[j]);
                lists[j] = null;
            }
        }
        return lists[0];
    }

用循环理解起来比较复杂，下面画图让大家感受一下。

步长是什么呢？如何确定呢？请看下图！

j 又该如何确定呢？

似懂非懂？那就继续看下去！！

这就是完整的解法啦~~
_{（思路1这里就不进行讲解了，只要懂了思路2，相信你思路1对你来说不在话下！）}
相信看到这里这道题的解法你已经掌握了，快给自己鼓鼓掌吧！！！

回头一看，博主竟然画了正正一大张的图！！
看到这里，是不是应该给博主疯狂点赞！！！！！！！！
_{不过说真的，看到满满一张的图，居然有一种极度舒适的感觉哈哈哈哈哈}

最后：

其实这道题虽然难度为困难，但是解完之后，就发现好像一点都不难喔~主要在于怎么将一个看起来好像有点复杂的问题分解成我们熟悉的问题：比如这里分解成合并两个链表，合并链表又可以分解成比较+尾插。

鸣谢：

力扣&力扣的大佬们 - 提供了如此丰富精彩的思路！
画图工具 - 让解题变得不再抽象！
傀儡头结点 - 被我们利用了那么多次，辛苦了！
最后的最后 - 感谢每一看过我的文章 & 给我点赞三连的好伙伴们！！！！

题目链接在此：快去拿下吧！~