Leetcode23——合并K个升序链表

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

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

示例 1：

输入：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
示例 2：

输入：lists = []
输出：[]
示例 3：

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

提示：

k == lists.length
0 <= k <= 10^4
0 <= lists[i].length <= 500
-10^4 <= lists[i][j] <= 10^4
lists[i] 按 升序 排列
lists[i].length 的总和不超过 10^4

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/merge-k-sorted-lists
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

其实就是两个升序队列的比较，就是先比较两个队列，另外的队列再和别的队列比较。所以我们有：

import java.util.List;

class ListNode {
    int val;
    ListNode next;
    ListNode() {}
    ListNode(int val) { this.val = val; }
    ListNode(int val, ListNode next) { this.val = val; this.next = next; } }

public class KListsIncrease {
    public static void main(String[] args) {
        Solution solution=new Solution();
        ListNode listNode1=new ListNode(1,new ListNode(4,new ListNode(5,null)));
        ListNode listNode2=new ListNode(1,new ListNode(3,new ListNode(4,null)));
        ListNode listNode3=new ListNode(2,new ListNode(6,null));
        ListNode[] lists={};
        ListNode h=solution.mergeKLists(lists);
        while(h!=null) {
            System.out.println(h.val);
            h=h.next;
        }
    }
}



class Solution {
    public ListNode combine(ListNode listnode1,ListNode listnode2){
        ListNode listNode=new ListNode();
        ListNode pointer=listNode;
        while(listnode1!=null && listnode2!=null){
            if(listnode1.val>listnode2.val){
                pointer.next=new ListNode(listnode2.val,null);
                listnode2=listnode2.next;
            }else{
                pointer.next=new ListNode(listnode1.val,null);
                listnode1=listnode1.next;
            }
            pointer=pointer.next;
        }
        if(listnode1!=null){
            pointer.next=listnode1;
        }
        if(listnode2!=null){
            pointer.next=listnode2;
        }
        listNode=listNode.next;
        return listNode;
    }
    public ListNode mergeKLists(ListNode[] lists) {
        ListNode head=new ListNode();
        ListNode pointer=head;
        if(lists.length!=0)
            head=lists[0];
        else
            return null;
        for(int i=1;i<lists.length;i++){
            ListNode listNode=combine(head,lists[i]);
            head=listNode;
        }
        return head;
    }
}

所以，combine是给定两个队列，进行升序队列的比较。

    public ListNode combine(ListNode listnode1,ListNode listnode2){
        ListNode listNode=new ListNode();
        ListNode pointer=listNode;
        while(listnode1!=null && listnode2!=null){
            if(listnode1.val>listnode2.val){
                pointer.next=new ListNode(listnode2.val,null);
                listnode2=listnode2.next;
            }else{
                pointer.next=new ListNode(listnode1.val,null);
                listnode1=listnode1.next;
            }
            pointer=pointer.next;
        }
        if(listnode1!=null){
            pointer.next=listnode1;
        }
        if(listnode2!=null){
            pointer.next=listnode2;
        }
        listNode=listNode.next;
        return listNode;
    }

而mergeKLists就是一个个进行排序：

 public ListNode mergeKLists(ListNode[] lists) {
        ListNode head=new ListNode();
        ListNode pointer=head;
        if(lists.length!=0)
            head=lists[0];
        else
            return null;
        for(int i=1;i<lists.length;i++){
            ListNode listNode=combine(head,lists[i]);
            head=listNode;
        }
        return head;
    }

结果：

 之后，我就在思考，这为什么是困难级别的题目，所以就去刷了别人的题解，发现原来别人用了分治的算法，就可以把N变为了log2N。原来对于速度的提升能快这么多。