LeetCode23 - 合并K个有序链表

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

合并K个有序链表，时间复杂度和空间复杂度有限制

解法一：优先队列求解，放一个排序一次logK，一共放N次，复杂度是NlogK

/**
 * 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;
        // 新建优先队列
        Queue<Integer> queue = new PriorityQueue<Integer>();
        // 将所有元素往队列放
        for(int i = 0; i< lists.length; i++) {
            while(lists[i] != null) {
                queue.offer(lists[i].val);
                lists[i] = lists[i].next;
            }
        }
        ListNode list = new ListNode(0);
        ListNode tmp = list;
        // 将队列元素取出构建链表
        while(!queue.isEmpty()) {
            int s = queue.poll();
            tmp.next = new ListNode(s);
            tmp = tmp.next;
        }
        return list.next;
    }
}

解法二（重点掌握）：优先队列求解，复杂度是NlogK，K 指针指向 K 条链表，每次使用小根堆来 logK 求出最小值，一共N个元素

/**
 * 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;
        // 新建优先队列
        Queue<ListNode> queue = new PriorityQueue<>((list1, list2) -> list1.val-list2.val);
        // 将所有元素往队列放
        for(int i = 0; i < lists.length; i++) {
            if(lists[i] != null)
                queue.offer(lists[i]);
        }
        ListNode list = new ListNode(0);
        ListNode tmp = list;
        // 将队列元素取出构建链表
        while(!queue.isEmpty()) {
            ListNode s = queue.poll();
            tmp.next = s;
            tmp = tmp.next;
            if(s.next != null) {
                queue.offer(s.next);
            }
        }
        return list.next;
    }
}

解法三：两两合并，时间复杂度，NK

/**
 * 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 ret = null;
        if(lists.length ==1) {
            return lists[0];
        }else if(lists.length == 2) {
            return merge2Lists(lists[0], lists[1]);
        }else {
            ret = merge2Lists(lists[0], lists[1]);
            for(int i=2; i<lists.length; i++) {
                ret = merge2Lists(ret, lists[i]);
            }
        }
        return ret;
    }

    private ListNode merge2Lists(ListNode list1, ListNode list2){
        ListNode res = new ListNode(0);
        ListNode temp = res;
        while(list1 != null && list2 != null) {
            if(list1.val < list2.val) {
                temp.next = new ListNode(list1.val);
                list1 = list1.next;
            }else {
                temp.next = new ListNode(list2.val);
                list2 = list2.next;
            }
            temp = temp.next;
        }
        if(list1 != null){
            temp.next = list1;
        }
        if(list2 != null) {
            temp.next = list2;
        }
        return res.next;
    }
}

解法四（重点掌握）：两两合并优化

时间复杂度分析：K 条链表的总结点数是 N，平均每条链表有 N/K 个节点，因此合并两条链表的时间复杂度是 O(N/K)。从 K 条链表开始两两合并成 1 条链表，因此每条链表都会被合并 logK 次，因此 K 条链表会被合并 K∗logK 次，因此总共的时间复杂度是 K∗logK∗N/K 即 O（NlogK）

/**
 * 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 ret = new ListNode(0);
        ListNode temp = ret;
        int n = lists.length;
        // 当lists就剩1个链表停止
        while(n>1) {
            // 从lists的第0个链表开始合并
            int idx = 0;
            for(int i=0; i<n; i+=2) {
                if(i == n-1) {
                    lists[idx++] = lists[i];
                }else {
                    lists[idx++] = merge2Lists(lists[i], lists[i+1]);
                }
            }
            n = idx;
        }
        return lists[0];
    }

    private ListNode merge2Lists(ListNode list1, ListNode list2){
        ListNode res = new ListNode(0);
        ListNode temp = res;
        while(list1 != null && list2 != null) {
            if(list1.val < list2.val) {
                temp.next = new ListNode(list1.val);
                list1 = list1.next;
            }else {
                temp.next = new ListNode(list2.val);
                list2 = list2.next;
            }
            temp = temp.next;
        }
        if(list1 != null){
            temp.next = list1;
        }
        if(list2 != null) {
            temp.next = list2;
        }
        return res.next;
    }
}