2021-06-26 合并k个有序链表

leetcode每日一题之合并k个有序链表

题目链接：https://leetcode-cn.com/problems/merge-k-sorted-lists/

题目描述：

给你一个链表数组，每个链表都已经按升序排列。

请你将所有链表合并到一个升序链表中，返回合并后的链表。

示例：

输入：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

输入：lists = []
输出：[]

输入：lists = [[]]
输出：[]

解法1：

两个两个得合并，需要用到合并两个有序链表的代码，非常简单，代码如下：

    public ListNode mergeKLists(ListNode[] lists) {
            //数组中没有元素或者只有一个空元素
            if (lists.length == 0 || lists == null) {
                return null;
            }
            //也就是将lists[0]和lists[1]合并成为lists[0-1],然后将lists[0-1]和之后得一个再次合并
            ListNode res = lists[0];
            for (int i = 1; i < lists.length; i++) {
                res = mergeTwoLists(res, lists[i]);
            }
            return res;
        }
    
        //两两合并链表
        public static ListNode mergeTwoLists(ListNode l1, ListNode l2) {
            //定义一个新的链表来连接
            ListNode listNode = new ListNode(-1);
            ListNode head = listNode;
            //1.如果两个链表中有一个为空，则直接返回另外一个链表
            if (l1 == null || l2 == null) {
                return l1 == null ? l2 : l1;
            }
            //2.如果两个链表都不为空且长度一样
            //输入：l1 = [1,2,4], l2 = [1,3,4]  输出：[1,1,2,3,4,4]
            while (l1 != null && l2 != null) {
                if (l1.val <= l2.val) {
                    listNode.next = l1;
                    l1 = l1.next;
                } else {
                    listNode.next = l2;
                    l2 = l2.next;
                }
                listNode = listNode.next;
            }
            //如果两个链表长度不一样
            listNode.next = (l1 == null ? l2 : l1);
            return head.next;
        }

解法2：使用堆排序。

代码：

    //使用堆排序
        public ListNode mergeKLists2(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;
                }
            });
            //输入：lists = [[1,4,5],[1,3,4],[2,6]]
            //输出：[1,1,2,3,4,4,5,6]
            //遍历链表数组，然后将链表得每个节点都放入堆中
            for (int i = 0; i < lists.length; i++) {
                while (lists[i] != null) {//lists[i] 表示链表得头节点
                    queue.add(lists[i]);
                    lists[i] = lists[i].next;
                }
            }
            ListNode dummy = new ListNode(0);
            ListNode head = dummy;
            //从堆中不断取出元素，并将这些元素串起来
            while (!queue.isEmpty()) {
                dummy.next = queue.poll();
                dummy = dummy.next;
            }
            dummy.next = null;
            return head.next;
        }
    

解法3：分治算法

代码：

    //分治[分为分解和合并两个步骤]
        //分治就是不断缩小问题规模，再不断合并扩大得过程
        public ListNode mergeKLists3(ListNode[] lists) {
            if (lists == null || lists.length == 0) {
                return null;
            }
            return hepler(lists, 0, lists.length - 1);
        }
    
        public ListNode hepler(ListNode[] lists, int begin, int end) {
            if (begin == end) {
                return lists[begin];
            }
            int mid = begin + (end - begin) >> 2;
            ListNode left = hepler(lists, begin, mid);
            ListNode right = hepler(lists, mid + 1, end);
            return mergeTwoLists2(left, right);
        }
    
        public static ListNode mergeTwoLists2(ListNode l1, ListNode l2) {
            //定义一个新的链表来连接
            ListNode listNode = new ListNode(-1);
            ListNode head = listNode;
            //1.如果两个链表中有一个为空，则直接返回另外一个链表
            if (l1 == null || l2 == null) {
                return l1 == null ? l2 : l1;
            }
            //2.如果两个链表都不为空且长度一样
            //输入：l1 = [1,2,4], l2 = [1,3,4]  输出：[1,1,2,3,4,4]
            while (l1 != null && l2 != null) {
                if (l1.val <= l2.val) {
                    listNode.next = l1;
                    l1 = l1.next;
                } else {
                    listNode.next = l2;
                    l2 = l2.next;
                }
                listNode = listNode.next;
            }
            //如果两个链表长度不一样
            listNode.next = (l1 == null ? l2 : l1);
            return head.next;
        }