面试题 10.01. 合并排序的数组

题目

给定两个排序后的数组 A 和 B，其中 A 的末端有足够的缓冲空间容纳 B。 编写一个方法，将 B 合并入 A 并排序。

初始化 A 和 B 的元素数量分别为 m 和 n。

示例：

输入:
A = [1,2,3,0,0,0], m = 3
B = [2,5,6],       n = 3

输出: [1,2,2,3,5,6]

分析： 对两个已经排序好的数组合并排序，直观上一种解法是先合并两个数组，然后进行排序，可以选择插入排序或者快排，第二种解法是采用双指针，从左到右遍历两个数组，每次取较小的放到新的空数组中

方法1： 合并数组然后排序
插入排序

class Solution:
    def merge(self, A: List[int], m: int, B: List[int], n: int) -> None:
        """
        Do not return anything, modify A in-place instead.
        """
        n = len(A)
        m = len(B)
        A[n-m:] = B
        for i in range(n-m, n):
            for j in range(i, 0, -1):
                if A[j] < A[j-1]:
                    A[j], A[j-1] = A[j-1], A[j]
                else:
                    break
        return A

快速排序

class Solution:
    def merge(self, A: List[int], m: int, B: List[int], n: int) -> None:
        """
        Do not return anything, modify A in-place instead.
        """
        n, m = len(A), len(B)
        A[n-m:] = B
        def quick_sort(l, r, a):
            if l >= r:
                return
            q = a[r-1]
            i = l-1
            for j in range(l, r):
                if a[j] <= q:
                    i += 1
                    a[i], a[j] = a[j], a[i]
            quick_sort(l, i, a)
            quick_sort(i+1, r, a)
            return
        quick_sort(0, n, A)
        return A

方法2： 双指针， 时间复杂度$O(m+n)$

class Solution:
    def merge(self, A: List[int], m: int, B: List[int], n: int) -> None:
        """
        Do not return anything, modify A in-place instead.
        """
        new_array = []
        n = len(A)
        m = len(B)
        i = j = 0
        while i < n-m and j < m:
            if A[i] < B[j]:
                new_array.append(A[i])
                i += 1
            else:
                new_array.append(B[j])
                j += 1
        new_array += A[i:n-m]
        new_array += B[j:m]
        A[:] = new_array
        return A