leetcode 23 Merge k Sorted Lists

题目：

Merge k sorted linked lists and return it as one sorted list. Analyze and describe its complexity.
地址

分析：

• 1. 每个链表已经是有序了的
• 2. 每个链表都有可能为空

思路：

• 1. 可以使用归并算法
     因为每个链表都已经是有序了的，所以跟归并算法非常相似
• 2. 可以使用最小堆
     首先直接将它们都加入堆中，则堆顶元素是最小值。
     只要堆不为空，就一直取出堆顶元素，加入到返回链表中。如果取出的元素的子节点不为空，还需要继续加入堆

方式一

使用归并排序的思路，递归调用。

假设：k = lists.length , n = lists中的最长的子链表长度

时间复杂度：nklogk
空间复杂度：nk

public class T023 {

    public static void main(String[] args) {

        int[] arr1 = {1, 2, 3, 4, 5};
        int[] arr2 = {-1, 2, 3, 4, 88};
        int[] arr3 = {1, 6, 33, 42, 44};
        int[] arr4 = {1, 7, 43, 52, 65};


        ListNode node1 = UtilListNode.makeListNode(arr1);
        ListNode node2 = UtilListNode.makeListNode(arr2);
        ListNode node3 = UtilListNode.makeListNode(arr3);
        ListNode node4 = UtilListNode.makeListNode(arr4);


        ListNode[] lists = {node1, node2, node3, node4};
        ListNode head = new T023().mergeKLists(lists);
        UtilListNode.show(head);
    }


    public ListNode mergeKLists(ListNode[] lists) {
        if (lists == null || lists.length == 0) return null;
        return mergeSort(lists, 0, lists.length-1);
    }

    // 归并排序的思路
    public ListNode mergeSort(ListNode[] lists, int l, int r) {
        if (l < r) {
            int mid = (r - l) / 2 + l;
            return mergeTwoLists(mergeSort(lists, l, mid), mergeSort(lists, mid + 1, r));
        }

        return lists[l];
    }


    // 排列两个有序了的链表
    public ListNode mergeTwoLists(ListNode l1, ListNode l2) {
        // 虚拟头节点
        ListNode dummy = new ListNode(0);
        ListNode head = dummy;

        while (l1 != null && l2 != null) {

            if (l1.val <= l2.val) {
                head.next = new ListNode(l1.val);
                l1 = l1.next;
            } else {
                head.next = new ListNode(l2.val);
                l2 = l2.next;
            }
            head = head.next;
        }

        while (l1 != null) {
            head.next = new ListNode(l1.val);
            l1 = l1.next;
            head = head.next;
        }

        while (l2 != null) {
            head.next = new ListNode(l2.val);
            l2 = l2.next;
            head = head.next;
        }
        
        return dummy.next;
    }
}

方式二

使用堆（优先队列）的方式，先将它们都加入队列，每次取出顶部元素，加入返回链表中。在看下该取出的元素的子节点是否为空，若不为空继续加入堆。

时间复杂度: 堆读取是 log(k)，一共有 n*k 个元素，则时间复杂度为：nklogk

空间复杂度：k

public class T023_2 {

    public static void main(String[] args) {

        int[] arr1 = {1, 2, 3, 4, 5};
        int[] arr2 = {-1, 2, 3, 4, 88};
        int[] arr3 = {1, 6, 33, 42, 44};
        int[] arr4 = {1, 7, 43, 52, 65};


        ListNode node1 = UtilListNode.makeListNode(arr1);
        ListNode node2 = UtilListNode.makeListNode(arr2);
        ListNode node3 = UtilListNode.makeListNode(arr3);
        ListNode node4 = UtilListNode.makeListNode(arr4);


        ListNode[] lists = {node1, node2, node3, node4};
        ListNode head = new T023_2().mergeKLists(lists);
        UtilListNode.show(head);
    }


    public ListNode mergeKLists(ListNode[] lists) {
        if (lists == null || lists.length == 0) return null;

        // 因为该链表已经是有序的，所以可以使用堆

        PriorityQueue heep = new PriorityQueue(11, new Comparator() {
            @Override
            public int compare(ListNode o1, ListNode o2) {
                return o1.val - o2.val;
            }
        });


        for (int i = 0; i < lists.length; i++) {
            // 加入堆中
            ListNode list = lists[i];
            if (list != null)
                heep.offer(list);
        }

        ListNode pre = null;
        ListNode head = null;


        while (!heep.isEmpty()) {
            // 取出堆顶
            ListNode cur = heep.poll();

            if (head == null) {
                head = cur;
            } else {
                pre.next = cur;
            }
            pre = cur;

            // 如果下个元素不为空，将它的下个元素加入堆
            if (cur.next != null) {
                heep.offer(cur.next);
            }
        }

        return head;
    }

}