归并排序-LeetCode23. 合并K个排序链表

1、题目描述

https://leetcode-cn.com/problems/merge-k-sorted-lists/

合并 k 个排序链表，返回合并后的排序链表。请分析和描述算法的复杂度。

2、代码详解

基础：21. 合并两个有序链表 https://blog.csdn.net/IOT_victor/article/details/107307546

2.1、合并K个排序链表

# Definition for singly-linked list.
class ListNode(object):
    def __init__(self, x):
        self.val = x
        self.next = None

class Solution(object):
    def mergeKLists(self, lists):
        """
        :type lists: List[ListNode]
        :rtype: ListNode
        """
        n = len(lists)
        if n == 0:
            return
        return self.merge(lists, 0, n - 1)

    # 分而治之（递归）
    def merge(self, lists, left, right):
        if left == right:
            return lists[left]
        mid = left + (right - left) // 2
        l1 = self.merge(lists, left, mid)
        l2 = self.merge(lists, mid + 1, right)
        return self.mergeTwoLists(l1, l2)  # 两两合并

    # LeetCode21. 合并两个有序链表
    def mergeTwoLists(self, l1, l2):
        if not l1:
            return l2  # 终止条件，直到两个链表都空
        if not l2:
            return l1
        # 判断 l1 和 l2 头结点哪个更小，然后较小结点的 next 指针指向其余结点的合并结果
        if l1.val < l2.val:
            l1.next = self.mergeTwoLists(l1.next, l2)
            return l1
        else:
            l2.next = self.mergeTwoLists(l1, l2.next)
            return l2

https://leetcode-cn.com/problems/merge-k-sorted-lists/solution/leetcode-23-he-bing-kge-pai-xu-lian-biao-by-powcai/

还有使用堆的解法，待续

 

2.2、合并k个排序数组（分治）

88. 合并两个有序数组+合并K个有序数组 https://blog.csdn.net/IOT_victor/article/details/107416249

题目链接：https://www.lintcode.com/problem/merge-k-sorted-arrays/description

# O(N log k) 的时间复杂度内完成：  N 是所有数组包含的整数总数量。 k 是数组的个数。
# 采用归并排序算法, 拆解到最后，实际变成两个数组进行排序
# 请牢记传入的参数是多维数组
def MergeSort(nums):
    # 此处是递归结束条件
    if len(nums) <= 1:
        return nums
    # 取中间位置 
    mid = len(nums) // 2
    # 此处实现递归
    # 记住此处得到的也是多维数组
    Left = MergeSort(nums[:mid])
    Right = MergeSort(nums[mid:])

    # print(Left[0], Right[0])
    # 要传入的参数是数组中第一个索引处的值
    return Sort_list(Left[0], Right[0])  # 合并

def Sort_list(Left, Right):
    res = []  # 存储排序后的值
    a = 0  # 游标a，Left数组的第一个元素
    b = 0  # 游标b，Right数组的第一个元素
    while a < len(Left) and b < len(Right):
        if Left[a] < Right[b]:
            res.append(Left[a])
            a += 1
        else:
            res.append(Right[b])
            b += 1
    # 因为存在一个到终点后，另一个还没到终点
    # 这时就需要将没到终点的剩下的值添加到数组中
    while a < len(Left):
        res.append(Left[a])
        a += 1
    while b < len(Right):
        res.append(Right[b])
        b += 1
    #将一维数组二维化
    res = [res]
    return res

if __name__ == '__main__':
    b = MergeSort([[1, 2, 3],
                   [2, 3, 5],
                   [6, 7, 9],
                   [7, 8, 9],
                   [3, 5, 6]])
    #print(b)

    #数组降维
    a = []
    for i in b[0]:
        a.append(i)
    #print(a)