合并k个链表

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

示例:

输入:
[
  1->4->5,
  1->3->4,
  2->6
]
输出: 1->1->2->3->4->4->5->6

 

有三种方法

1、把所有元素入最小堆，再输出堆顶实现，堆可以用java的PriorityQueue实现

2、每两个链表归并，最后再两两归并，直到完全归并 （一颗自底向上的二叉树）

3、分治法将k个链表分为1～k/2和k/2+1～k两部分归并，1～k/2又可以分为1～k/4和k/4+1～k/2，k/2+1～k又可以分为两半，然后最后再把它们合并起来（一颗自顶向下的二叉树）

这三种方法的时间复杂度都是O(nlogk)

 

第一种办法

public ListNode mergeKLists(ListNode[] lists) {
        PriorityQueue<Integer> minHeap = new PriorityQueue<>();

        for (int i = 0; i < lists.length; i++) {
            while(lists[i]!= null) {
                ListNode listNode = lists[i];
                minHeap.add(listNode.val);
                lists[i] = lists[i].next;
                listNode.next = null;
            }
        }
        ListNode listNode = new ListNode(0);
        ListNode res = listNode;
    

        while (!minHeap.isEmpty()) {
            ListNode tmp = new ListNode(minHeap.poll());
            res.next = tmp;
            res = res.next;


        }

        return listNode.next;
   
}

第二种办法

 public ListNode mergeKLists(ListNode[] lists) {
        if (lists.length == 0) return null;
        if (lists.length == 1) return lists[0];
        int n = lists.length % 2 == 1 ? lists.length / 2 + 1 : lists.length / 2;
        ListNode resultNode = new ListNode(0);
        ListNode[] tmpNode = lists;
        while (true) {
            ListNode[] listNodes = new ListNode[n];
            for (int i = 0; i < n; i++) {
                if (2 * i + 1 < tmpNode.length) {
                    listNodes[i] = mergeTwoSort(tmpNode[2 * i], tmpNode[2 * i + 1]);
                } else listNodes[i] = tmpNode[2 * i];
            }
            tmpNode = listNodes;
            n = listNodes.length == 1 ? 0 : listNodes.length % 2 == 1 ? listNodes.length / 2 + 1 : listNodes.length / 2;

            if (n == 0) {
                resultNode.next = listNodes[0];
                break;
            }
        }
        return resultNode.next;

    }

    private ListNode mergeTwoSort(ListNode list, ListNode list1) {
        ListNode listNode = new ListNode(0);
        ListNode res = listNode;
        while (list != null && list1 != null) {
            ListNode tmp = null;
            if (list.val < list1.val) {
                tmp = list;
                list = list.next;
            } else {
                tmp = list1;
                list1 = list1.next;
            }
            res.next = tmp;
            res = res.next;
            tmp.next = null;
        }

        if (list != null) {
            res.next = list;
        }
        if (list1 != null) {
            res.next = list1;
        }
        return listNode.next;
    }
}

第三种办法

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

    private ListNode backtracking(ListNode[] lists, int start, int end) {
        
        if (start + 1 == end) {
            return mergeTwoSort(lists[start], lists[end]);
        } else if (start == end)
            return lists[start];
        
        ListNode listNode = backtracking(lists, start, start+ (end - start) / 2);
        ListNode listNode1 = backtracking(lists,start+ (end - start) / 2 + 1, end);
        return mergeTwoSort(listNode, listNode1);
    }

    private ListNode mergeTwoSort(ListNode list, ListNode list1) {
        ListNode listNode = new ListNode(0);
        ListNode res = listNode;
        while (list != null && list1 != null) {
            ListNode tmp = null;
            if (list.val < list1.val) {
                tmp = list;
                list = list.next;
            } else {
                tmp = list1;
                list1 = list1.next;
            }
            res.next = tmp;
            res = res.next;
            tmp.next = null;
        }

        if (list != null) {
            res.next = list;
        }
        if (list1 != null) {
            res.next = list1;
        }
        return listNode.next;
    }