【力扣】23. 合并 K 个升序链表 ＜链表指针、堆排序、分治＞

【力扣】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$

题解

方法一：暴力，先遍历取出来值到数组中排序，再生成新链表

import java.util.*;

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 dummyNode = new ListNode(-1);
        ListNode prev = dummyNode;

		//先遍历取出来值到数组中排序
        List<Integer> nodes = new ArrayList();
        for(ListNode list: lists){
            while(list != null){
                nodes.add(list.val);
                list = list.next;
            }
        }
        Collections.sort(nodes);

		//生成新链表
        for(int x : nodes){
            prev.next = new ListNode(x);
            prev = prev.next;
        }

        return dummyNode.next;
    }
}

方法二：基础堆排序（使用优先队列 PriorityQueue）

思路：遍历数组每个值，建小顶堆，照着小顶堆依次取堆顶元素并移除，直到堆空

import java.util.*;

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;
        }

        //创建一个堆（优先队列），并设置元素的排序方式
        PriorityQueue<ListNode> queue = new PriorityQueue(new Comparator<ListNode>() {
            @Override
            public int compare(ListNode o1, ListNode o2) {
                return (o1.val - o2.val);
            }
        });

        //遍历链表数组，然后将每个链表的每个节点都放入堆中
        for(ListNode list: lists){
            while(list != null){
                queue.add(list);
                list = list.next;
            }
        }

        ListNode dummyNode = new ListNode(-1);
        ListNode prev = dummyNode;

        //从堆中不断取出元素，并将取出的元素串联起来
        while (!queue.isEmpty()) {
            prev.next = queue.poll();
            prev = prev.next;
        }
        prev.next = null;

        return dummyNode.next;
    }
}

方法三：基础堆排序（使用优先队列 PriorityQueue）

思路：只遍历每个数组第一个值（k 个），建小顶堆，照着小顶堆依次取堆顶元素并移除，移除的同时，如果这个值原来还有next 就补齐 k个到堆里，继续取堆顶移除。

因为：k 个链表中的最小值，一定来自 k 个递增链表中某一个的第一个值。将原先的 O(N) 的空间复杂度优化到 O(k)

import java.util.*;

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;
        }

        //创建一个小根堆，并定义好排序函数
        PriorityQueue<ListNode> queue = new PriorityQueue(new Comparator<ListNode>() {
            @Override
            public int compare(ListNode o1, ListNode o2) {
                return (o1.val - o2.val);
            }
        });

        //这里不再是一股脑全部放到堆中,而是只把 k 个链表的第一个节点放入到堆中
        for (ListNode list : lists) {
            ListNode eachHead = list;
            if (eachHead != null) {
                queue.add(eachHead);
            }
        }

        ListNode dummyNode = new ListNode(-1);
        ListNode prev = dummyNode;
        //之后不断从堆中取出节点，如果这个节点所在的链表还有下一个节点，就将下个节点也放入堆中
        while (queue.size() > 0) {
            ListNode node = queue.poll();
            prev.next = node;
            prev = prev.next;
            if (node.next != null) {
                queue.add(node.next);
            }
        }

        prev.next = null;
        return dummyNode.next;
    }
}

方法四：递归

合并两个链表的思路来合并 k 个链表

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;
        }
        // 将 lists[0] 作为最终合并的链表，然后将 list[0] 和 lists[1] 合并成 lists[0-1]
        // 再将 lists[0-1] 和 lists[2] 合并，如此反复最终 lists[0] 就是最终结果
        ListNode res = lists[0];
        for (int i = 1; i < lists.length; i++) {
            res = merge(res, lists[i]);
        }

        return res;
    }

    // 合并两个有序链表,递归版本
    private ListNode merge(ListNode l1, ListNode l2) {
        //递归的结束条件，如果 l1 和 l2 中有一个为空就返回
        if (l1 == null || l2 == null) {
            return (l1 == null) ? l2 : l1;
        }

        //如果 l1 的值 <=l2 的值，就继续递归，比较 l1.next 的值和 l2 的值
        //l1.next 和 l2 比较完后，会产生一个更小的节点 x，将 x 加到当前 l1 的后面
        if (l1.val <= l2.val) {
            l1.next = merge(l1.next, l2);
            return l1;
        }
        //如果 l1 的值 >l2 的值，就继续递归，比较 l1 的值和 l2.next 的值
        else {
            l2.next = merge(l1, l2.next);
            return l2;
        }
    }
}

方法五：分治

  一开始数组的规模是 k，找到中间点，一分为二，然后再拆分，直到不能再拆分 (规模为1时) 时便返回。之后开始合并，合并的代码借用了合并两个排序链表的代码。
  当两个规模最小的链表合并完后，其规模就变大了，然后不断重复这个合并过程，直到最终得到一个有序的链表。
  分治就是不断缩小其规模，再不断合并扩大的过程

class Solution {
    public ListNode mergeKLists(ListNode[] lists) {
        // 边界
        if (lists == null || lists.length == 0) {
            return null;
        }
        //分治
        return helper(lists, 0, lists.length - 1);
    }


    //通过合并两个链表，不断增大其规模，整体看就是不断缩小-最后不断扩大的过程
    private ListNode helper(ListNode[] lists, int begin, int end) {
        if (begin == end) {
            return lists[begin];
        }

        //通过 mid 将数组一分为二，并不断缩小规模，当规模为 1 时返回并开始合并
        int mid = begin + (end - begin) / 2;
        ListNode left = helper(lists, begin, mid);
        ListNode right = helper(lists, mid + 1, end);

        return merge(left, right);
    }

    // 合并两个有序链表,递归版本
    private ListNode merge(ListNode l1, ListNode l2) {
        //递归的结束条件，如果 l1 和 l2 中有一个为空就返回
        if (l1 == null || l2 == null) {
            return (l1 == null) ? l2 : l1;
        }

        //如果 l1 的值 <=l2 的值，就继续递归，比较 l1.next 的值和 l2 的值
        //l1.next 和 l2 比较完后，会产生一个更小的节点 x，将 x 加到当前 l1 的后面
        if (l1.val <= l2.val) {
            l1.next = merge(l1.next, l2);
            return l1;
        }
        //如果 l1 的值 >l2 的值，就继续递归，比较 l1 的值和 l2.next 的值
        else {
            l2.next = merge(l1, l2.next);
            return l2;
        }
    }
}