Leetcode刷题——23. 合并K个升序链表

21. 合并两个有序链表

先看看这题合并两个有序链表
思路：找出两个链表中较小的元素链接到结果链表，当有一个链表为空时，另一个直接连接到目标结尾即可。

public ListNode mergeTwoLists(ListNode list1, ListNode list2) {
    
        ListNode listNode = new ListNode();
        ListNode res = listNode;
        while (list1!=null && list2!=null){
    
            int val1= list1.val;
            int val2= list2.val;
            if(val1<val2){
    
                listNode.next=list1;
                list1=list1.next;
            }else{
    
                listNode.next=list2;
                list2=list2.next;
            }
            listNode=listNode.next;
        }
        if(list1!=null){
    
            listNode.next=list1;
        }
        if(list2!=null){
    
            listNode.next=list2;
        }
        return res.next;
    }

23. 合并K个升序链表

再看这道题：
23. 合并K个升序链表

首先第一思路是就是两两合并。
代码如下：

public ListNode mergeKLists(ListNode[] lists) {
    
        if(lists.length == 0){
    
            return null;
        }
        if(lists.length==1){
    
            return lists[0];
        }
        for (int i = 1; i < lists.length; i++) {
    
            lists[i]=mergeTwoLists(lists[i],lists[i-1]);
        }   
        return lists[lists.length-1];
    }

这样实现起来虽然简单，但是时间效率很差，因为合并是O(n)，每次都遍历和之前的合并，时间复杂度也是O(n)，所以之间复杂度是O(n^2)

归并排序

其实很容易想到，里面有很多冗余的步骤，可以两两合并，也就是我们熟悉的归并排序。
在我们用数组排序的时候，创建一个新的数组，每次归并，都对指定指定位置的元素修改。
而这里链表则是每次都返回排序好的链表进行合并。
在归并的底层是单个元素，所以当left == right的时候，直接返回当前元素。
代码：

private static ListNode mergeLists(ListNode[] lists,int left ,int right) {
    
        int mid = (left+right)/2;
        if(left == right){
    
            return lists[left];
        }
        if(left<right){
    
            ListNode listNode1 = mergeLists(lists, left, mid);
            ListNode listNode2 = mergeLists(lists, mid + 1, right);
            return mergeTwoLists(listNode1,listNode2);
// mergeTwoLists(lists[left],l)
        }
        return null;
    }

这样的话时间复杂度就变成了O（n*logn）