给你一个链表数组，每个链表都已经按升序排列。
请你将所有链表合并到一个升序链表中，返回合并后的链表。
示例 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
先对所有元素合并再排队（sort内置函数），之后按序链接：
/**
* Definition for singly-linked list.
* type ListNode struct {
* Val int
* Next *ListNode
* }
*/
func mergeKLists(lists []*ListNode) *ListNode {
result := make([]*ListNode,0)
for i := 0;i<len(lists);i++ {
tmp := lists[i]
for tmp != nil {
result = append(result,tmp)
tmp = tmp.Next
}
}
sort.Slice(result,func(i,j int) bool {
return result[i].Val < result[j].Val
})
for i := 0;i<len(result)-1;i++ {
result[i].Next = result[i+1]
}
if len(result) == 0 {
return nil
}
result[len(result)-1].Next = nil
return result[0]
}
分治法：
/**
* Definition for singly-linked list.
* type ListNode struct {
* Val int
* Next *ListNode
* }
*/
func mergeKLists(lists []*ListNode) *ListNode {
if len(lists) ==0 {
return nil
}
if len(lists) == 1 {
return lists[0]
}
l1 := mergeKLists(lists[:len(lists)/2])
l2 := mergeKLists(lists[len(lists)/2:])
result := &ListNode{}
tmp := result
for l1 != nil && l2 != nil {
if l1.Val < l2.Val {
tmp.Next = l1
l1 = l1.Next
} else {
tmp.Next = l2
l2 = l2.Next
}
tmp = tmp.Next
}
if l1 != nil {
tmp.Next = l1
} else {
tmp.Next = l2
}
return result.Next
}
