23. 合并K个升序链表

链表算法题（程序员面试宝典）

解题思路主要来源于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^4
0 <= lists[i].length <= 500
-10^4 <= lists[i][j] <= 10^4
lists[i] 按 升序 排列
lists[i].length 的总和不超过 10^4

解题方法

解题思路1

借助两两合并思想，合并多个升序链表。

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode() {}
 *     ListNode(int val) { this.val = val; }
 *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
 * }
 */
class Solution {
    public ListNode mergeKLists(ListNode[] lists) {
        if(lists==null||lists.length==0){
            return null;
        }
        //两两合并思想
        ListNode mergeNode = lists[0];
        for(int i =1;i<lists.length;i++){
            mergeNode = merge(mergeNode,lists[i]);
        }
        return mergeNode;
    }

    public ListNode merge(ListNode a,ListNode b){
        //递归思想  合并两个升序链表
        if(a==null){
            //a 链表为空
            return b;
        }
        if(b==null){
            //b 链表为空
            return a;
        }
        if(a.val<b.val){
            a.next = merge(a.next,b);
            return a;
        }else{
            b.next = merge(a,b.next);
            return b;
        }
    }
}

解题思路2

分治法，先分割后合并。

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode() {}
 *     ListNode(int val) { this.val = val; }
 *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
 * }
 */
class Solution {
    public ListNode mergeKLists(ListNode[] lists) {
        //分治思想
        if(lists==null||lists.length==0){
            return null;
        }
        return divide(lists,0,lists.length-1);
    }

    public ListNode divide(ListNode[] lists,int start,int end){
        //先拆分
        if(start==end){
            return lists[start];
        }
        int mid = start + (end - start)/2;
        ListNode left = divide(lists,start,mid);
        ListNode right = divide(lists,mid+1,end);
        return merge(left,right);
    }

    public ListNode merge(ListNode a,ListNode b){
        //递归思想  合并两个升序链表
        if(a==null){
            //a 链表为空
            return b;
        }
        if(b==null){
            //b 链表为空
            return a;
        }
        if(a.val<b.val){
            a.next = merge(a.next,b);
            return a;
        }else{
            b.next = merge(a,b.next);
            return b;
        }
    }
}

解题思路3

图来源：https://leetcode-cn.com/problems/merge-k-sorted-lists/solution/duo-tu-yan-shi-23-he-bing-kge-pai-xu-lian-biao-by-/
从四个节点中选出最小的节点，链接到新链表中，然后将minNode = minNode.next。

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode() {}
 *     ListNode(int val) { this.val = val; }
 *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
 * }
 */
class Solution {
    public ListNode mergeKLists(ListNode[] lists) {
        //K 个指针
        int k = lists.length;
        //创建空头和尾指针,来指示合并后的新链表
        ListNode dummy = new ListNode(-1);
        ListNode tailNode = dummy;
        
        while(true){

            //记录最小节点和最小节点的下标
            ListNode minNode = null;
            int minIndex = -1;

            for(int i =0;i<k;i++){
                //找到当前k个节点的最小值
                if(lists[i]!=null){
                    if(minNode==null||lists[i].val<minNode.val){
                        //如果当前节点小于minNode节点值
                        //更新minNode,minIndex
                        minNode = lists[i];
                        minIndex = i;
                    }
                }
            }

            if(minIndex==-1){
                //链表为空
                break;
            }

            //找到最小节点minNode，链接到新链表中
            tailNode.next = minNode;
            tailNode = tailNode.next;
            //更新minIndex的值
            lists[minIndex] = lists[minIndex].next;
        }
        
        return dummy.next;

    }
}