day14-合并K个有序链表

day14-合并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

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/merge-k-sorted-lists

解题思路

这道题类似于合并两个有序链表的加强版，所以我们可以从合并两个有序链表的基础思路出发，已知两个链表时每次循环比较两个链表的头节点值的大小，将小的放到合并链表末尾，然后头指针后移，所以针对多条链表我们可以再加一层循环，遍历每个链表的头节点，然后选出最小的一个放到合并链表的结尾。

方法一：循环

解题代码

/**
 * 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) {
        ListNode linked = new ListNode();
        ListNode next = linked;
        while(lists.length!=0){
            int m = 0;
            boolean flag = true;
            for(int i=0;i<lists.length;++i){
                if(lists[i]==null){
                    continue;
                }else if(flag){
                    m=i;
                }
                flag = false;
                if(lists[i].val<lists[m].val){
                    m = i;
                }
            }
            if(flag){
                break;
            }
            next.next = lists[m];
            next = next.next;
            lists[m] = lists[m].next;
        }
        return linked.next;
    }
}

执行效率

方法二：优先队列

针对方法一的基础上使用优先队列(PriorityQueue)进行优化，因为我们每次的内层循环只是为了找出所有链表头节点最小的一个，所以我们可以借助优先队列进行代替，java中的优先队列(PriorityQueue)可以在创建时自定义优先(排序)规则，所以我们可以将头节点都放到优先队列中，并自定义排序顺序为节点的值升序，这样我们每次从队列中poll的时候总是最小的一个，然后再将poll出来的节点的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) {
        ListNode linked = new ListNode();
        ListNode heard = linked;
        if(lists==null||lists.length==0){
            return null;
        }
        PriorityQueue<ListNode> queue = new PriorityQueue<ListNode>((o1,o2)->o1.val-o2.val);
        for(ListNode node : lists){
            if(node!=null){
                queue.offer(node);
            }
        }
        ListNode node = null;
        while(!queue.isEmpty()){
            node = queue.poll();
            linked.next = node;
            linked = linked.next;
            if(node.next!=null){
                queue.offer(node.next);
            }
        }
        return heard.next;
    }
}

执行效率

方法三：分而治之(二分法)

既然我们会两个链表的合并，那么对于k个链表我们让其两两合并，然后合并的结果载两两合并，直到合并为一条链表即可。

解题代码

/**
 * 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) {
        ListNode linked = new ListNode();
        ListNode heard = linked;
        if(lists==null||lists.length==0){
            return null;
        }
        return merge(lists,1,lists.length/2,lists.length);
    }
    public ListNode merge(ListNode[] lists,int left,int mid,int right){
        if(left==right){
            return lists[left-1];
        }
        if(left==right-1){
            return mergeTwo(lists[left-1],lists[right-1]);
        }
        return mergeTwo(merge(lists,left,(left+mid)/2,mid),merge(lists,mid+1,(mid+right)/2,right));
    }
    public ListNode mergeTwo(ListNode node1,ListNode node2){
        ListNode linked = new ListNode();
        ListNode next = linked;
        while(node1!=null&&node2!=null){
            if(node1.val<node2.val){
                next.next = node1;
                node1 = node1.next;
                next = next.next;
            }else{
                next.next = node2;
                node2 = node2.next;
                next = next.next;
            }
        }
        next.next = node1!=null ? node1 : node2;

        return linked.next;
    }
}

执行效率