[leetcode]23. Merge k Sorted Lists

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

Leetcode 21题是合并两个链表。合并K个链表的方法就是2的进一步。有两种方法：

1 归并法。即每次链表数组中相邻的两个链表合并，结果为一个新的链表数组，重复之前的流程知道数组中只有一个元素为止。

2 按部就班法。从链表数组的第一个链表不断和后面的链表合并存到第一个链表处，最后返回第一个链表。

java代码：方法1

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) { val = x; }
 * }
 */
public class Solution {
    public ListNode mergeKLists(ListNode[] lists) {
       ListNode[] res =  mergek(lists);
       if(res.length==0){
           return null;
       }
       else{
           return res[0];
       }
    }
    public ListNode[] mergek(ListNode[] list){
        if(list.length==0||list.length==1){
            return list;
        }
        else{
            int len = list.length;
            int newLength = 0;
            if(len%2==0){
                newLength=len/2;
            }
            else{
                newLength=len/2+1;
            }
            ListNode[] tmp = new ListNode[newLength];
            int index=0;
            for(int i=0;i<len;i+=2){
                if((i+1)<len){
                 tmp[index++]=mergeTwoLists(list[i],list[i+1]);
                }
                else{
                    tmp[index++]=list[i];
                }
            }
            return mergek(tmp);
        }
    }
     public ListNode mergeTwoLists(ListNode l1, ListNode l2) {
        
        if(l1==null&&l2==null)
        {
            return null;
        }
        if(l1==null)
        {
            return l2;
        }
        if(l2==null)
        {
            return l1;
        }
        ListNode cur=null,head=null;
        ListNode node1=l1,node2=l2;
        while(node1!=null&&node2!=null)
        {
            if(node1.val<node2.val)
            {
                if(cur==null)
                {
                    cur=node1;
                }
                else
                {
                    cur.next=node1;
                    cur=node1;
                }
                node1=node1.next;
            }
            else
            {
                if(cur==null)
                {
                    cur=node2;
                }
                else
                {
                    cur.next=node2;
                    cur=node2;
                }
                node2=node2.next;
            }
            
        }
        while(node1!=null)
        {
            cur.next=node1;
            cur=node1;
            node1=node1.next;
        }
        while(node2!=null)
        {
            cur.next=node2;
            cur=node2;
            node2=node2.next;
        }
        if(l1.val<l2.val)
        {
            return l1;
        }
        else
        {
            return l2;
        }
        
    }
}

go代码：方法2

/**
 * Definition for singly-linked list.
 * type ListNode struct {
 *     Val int
 *     Next *ListNode
 * }
 */
func mergeKLists(lists []*ListNode) *ListNode {
    if len(lists)==0{
        return nil
    }else if len(lists)==1{
        return lists[0]
    }else{
        for i:=1;i<len(lists);i++{
            lists[0]=mergeTwoLists(lists[0],lists[i])
        }
        return lists[0]
    }
}
func mergeTwoLists(l1 *ListNode, l2 *ListNode) *ListNode {
    if l1 == nil && l2 == nil{
        return nil
    }
    if l1==nil{
        return l2
    }
    if l2 == nil{
        return l1;
    }
    var head,cur *ListNode
    for l1!=nil&&l2!=nil{
        if l1.Val<l2.Val{
            if head == nil{
                head = l1
                cur = l1
            }else{
                cur.Next = l1
                cur=cur.Next
            }
            l1=l1.Next
        }else{
            if head == nil{
                head = l2
                cur = l2
            }else{
                cur.Next = l2
                cur=cur.Next
            }
            l2=l2.Next
        }
    }
    if l1!=nil{
        cur.Next=l1
    }
    if l2!=nil{
        cur.Next=l2
    }
    return head
}