LeetCode-Linked List-23-H：合并K个排序链表

合并 k 个排序链表，返回合并后的排序链表。请分析和描述算法的复杂度。

思路

（1）普通的暴力解法。没有什么思路，遍历一遍过去的时间复杂度，两个依次比较、合并。
（2）在方法（1）的基础上进行改进，对称合并，而不是一一合并。

解法1-AC

执行用时 :131 ms, 在所有 Java 提交中击败了27.09%的用户
内存消耗 :56.9 MB, 在所有 Java 提交中击败了14.42%的用户

class Solution {
    public ListNode mergeKLists(ListNode[] lists) {
        int num = lists.length;
        // error1 if(lists == null){ return lists;}
        if(num == 0){
            return null;
        }
        
        for(int i = 0; i<num-1; i++){
            ListNode temp=merge(lists[i], lists[i+1]);
            lists[i+1] = temp;
        }
        return lists[num-1];
    }

    // merge two list
    ListNode merge(ListNode list1, ListNode list2){
        ListNode node1 = list1;
        ListNode node2 = list2;
        ListNode head = new ListNode(0);
        ListNode root = head;

        while(list1 != null && list2 != null){
            if(list1.val < list2.val){
                root.next = list1;
                list1 = list1.next;
            }else{
                root.next = list2;
                list2 = list2.next;
            }
            root = root.next;
        }

        root.next = list1 == null ? list2 : list1;
        return head.next;
    }
}

解法2-对折

执行用时 :3 ms, 在所有 Java 提交中击败了85.60%的用户
内存消耗 :42.6 MB, 在所有 Java 提交中击败了40.52%的用户

    public ListNode mergeKLists(ListNode[] lists) {
      int len = lists.length;
        if (len == 0) {
            return null;
        }    
        // 将n个链表以中间为对称，合并，即合并 
        while(len>1) {
            for (int i=0; i<len/2; i++) {
                lists[i] = mergeTwoLists(lists[i], lists[len-1-i]);
            }
            len = (len+1)/2;
        }
        return lists[0];
    }