合并 K 个升序链表

合并 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 = [[]]
输出：[]

题解：

粗暴一点，两两列表合并依次合并整个列表

/**
 * Definition for singly-linked list.
 * type ListNode struct {
 *     Val int
 *     Next *ListNode
 * }
 */
func mergeKLists(lists []*ListNode) *ListNode {
	var ans *ListNode
	for _, l := range lists {
		ans = merge(ans, l)
	}
	return ans
}

func merge(l1, l2 *ListNode) *ListNode {
	head := &ListNode{}
	tmp, p, q := head, l1, l2
	for p != nil && q != nil {
		if p.Val < q.Val {
			tmp.Next = p
			p = p.Next
		} else {
			tmp.Next = q
			q = q.Next
		}
		tmp = tmp.Next
	}
	if p != nil {
		tmp.Next = p
	}
	if q != nil {
		tmp.Next = q
	}
	return head.Next
}

优化

/**
 * Definition for singly-linked list.
 * type ListNode struct {
 *     Val int
 *     Next *ListNode
 * }
 */
func mergeKLists(lists []*ListNode) *ListNode {
	if len(lists) == 0 {
        return nil
    }
    return mergeRange(lists, 0, len(lists)-1)
}

func mergeRange(lists []*ListNode, left, right int) *ListNode {
    if left == right {
        return lists[left]
    }
    mid := (left + right) / 2
    l1 := mergeRange(lists, left, mid)
    l2 := mergeRange(lists, mid+1, right)
    return merge(l1, l2)
}

func merge(l1, l2 *ListNode) *ListNode {
	head := &ListNode{}
	tmp, p, q := head, l1, l2
	for p != nil && q != nil {
		if p.Val < q.Val {
			tmp.Next = p
			p = p.Next
		} else {
			tmp.Next = q
			q = q.Next
		}
		tmp = tmp.Next
	}
	if p != nil {
		tmp.Next = p
	}
	if q != nil {
		tmp.Next = q
	}
	return head.Next
}