LeetCode 23. 合并K个升序链表

23. 合并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-大佬题解
• 迭代法：k个链表的合并，可以看做是k-1次，每两个链表之间的合并。但是这种方法的时间复杂度较高（不推荐）。
• 补充：此题是 剑指 Offer 25. 合并两个排序的链表_dreamer'~的博客-CSDN博客 的升级版

时间复杂度：O(nlog⁡k)，其中 k 为 lists 的长度，n 为所有链表的节点数之和。每个节点参与链表合并的次数为 O(log⁡k) 次，一共有 n 个节点，所以总的时间复杂度为 O(nlog⁡k)。

 空间复杂度：O(log⁡k) 递归深度为 O(log⁡k)，需要用到 O(log⁡k)的栈空间。

/**
 * Definition for singly-linked list.
 * type ListNode struct {
 *     Val int
 *     Next *ListNode
 * }
 */

// 参考题解 分治法：https://leetcode.cn/problems/merge-k-sorted-lists/solutions/2384305/liang-chong-fang-fa-zui-xiao-dui-fen-zhi-zbzx/
// 方法1：递归（推荐）
// 时间复杂度：O(nlog⁡k)，其中 k 为 lists 的长度，n 为所有链表的节点数之和。每个节点参与链表合并的次数为 O(log⁡k) 次，一共有 n 个节点，所以总的时间复杂度为 O(nlog⁡k)
// 空间复杂度：O(log⁡k) 递归深度为 O(log⁡k)，需要用到 O(log⁡k)的栈空间。
func mergeKLists(lists []*ListNode) *ListNode {
    length := len(lists)
    if length == 0 {
        return nil
    }

    if length == 1 {
        return lists[0]
    }

    left := mergeKLists(lists[:length/2])   // 对左半部分分治
    right := mergeKLists(lists[length/2:])  // 对右半部分分治
    return mergeTwoLists(left, right)       // 最后把左右两部分合并
}

func mergeTwoLists(list1 *ListNode, list2 *ListNode) *ListNode {
    head := &ListNode{}
    cur  := head

    // for循环的&&写法
    for list1 != nil && list2 != nil {
        if list1.Val < list2.Val {
            cur.Next = list1
            list1 = list1.Next
        } else {
            cur.Next = list2
            list2 = list2.Next
        }
        cur = cur.Next
    }

    // 若某一个链表空了，直接拼接剩余的另一个链表即可，不需要再逐个连接了
    if list1 == nil {
        cur.Next = list2
    } else {
        cur.Next = list1
    }  

    return head.Next
}

// 方法2：迭代（不推荐）：k个链表的合并，可以看做是链表两两之间进行合并
// 时间复杂度 O(nk)，时间复杂度高于上述递归法
// func mergeKLists(lists []*ListNode) *ListNode {
//     var res *ListNode // res := &ListNode{} // 错误写法，会初始化res为0值，导致结果集多一个0值
//     for i := 0; i < len(lists); i++ {
//         res = mergeTwoLists(res, lists[i])
//     }

//     return res
// }

// func mergeTwoLists(l1, l2 *ListNode) *ListNode {
//     // var head *ListNode // 错误写法 会空指针异常
//     head := &ListNode{}
//     cur := head

//     // for循环的||写法
//     for l1 != nil || l2 != nil {
//         if l1 != nil && l2 != nil {
//             if l1.Val < l2.Val {
//                 cur.Next = l1
//                 l1 = l1.Next
//             } else {
//                 cur.Next = l2
//                 l2 = l2.Next
//             }
//             cur = cur.Next

//         } else if l1 != nil {
//             cur.Next = l1
//             break
//         } else if l2 != nil {
//             cur.Next = l2
//             break
//         }
//     }

//     return head.Next
// }