就地合并排序 | 2套

介绍

就地合并排序，是一种排序算法，也被称为原址归并排序，它可以将两个已经排好序的数组合并成一个更大的已排好序的数组。 该算法使用两个指针i和j，分别指向两个已经排序好的数组的开头，然后比较指针所指的元素大小，将较小的元素放入新数组中，直到其中一个数组遍历完为止。然后将剩下的未遍历的数组中的元素加入到新数组中。

在本文中，我们将介绍两种方法实现就地合并排序。

方法一：逆向扫描

逆向扫描是通过比较两个数组（a和b）的最后一个元素的大小进行合并。 具体实现步骤如下：

1. 定义两个指针i和j，分别指向两个已经排序好的数组的末尾。
2. 定义一个指针k，指向新数组（c）的末尾。
3. 比较a[i]和b[j]的大小，如果a[i]较大，就将a[i]放入c[k]中，i--， 否则将b[j]放入c[k]中，j--。
4. 重复第3步，直到其中一个数组遍历完为止。
5. 如果其中一个数组已经遍历完了，将另一个数组中的元素加入到c数组中。

def sort_merge(A: List[int], B: List[int]) -> List[int]:
    len_a, len_b = len(A), len(B)
    A += [0] * len_b
  
    i = len_a - 1
    j = len_b - 1
    k = len(A) - 1

    while i >= 0 and j >= 0:
        if A[i] > B[j]:
            A[k] = A[i]
            i -= 1
        else:
            A[k] = B[j]
            j -= 1
        k -= 1

    while j >= 0:
        A[k] = B[j]
        j -= 1
        k -= 1

    return A

方法二：正向扫描

正向扫描是通过比较两个数组（a和b）的最小元素的大小进行合并。 具体实现步骤如下：

1. 定义两个指针i和j，分别指向两个已经排序好的数组的开头。
2. 定义一个指针k，指向新数组（c）的开头。
3. 比较a[i]和b[j]的大小，如果a[i]较小，就将a[i]放入c[k]中，i++， 否则将b[j]放入c[k]中，j++。
4. 重复第3步，直到其中一个数组遍历完为止。
5. 如果其中一个数组已经遍历完了，将另一个数组中的元素加入到c数组中。

def sort_merge(A: List[int], B: List[int]) -> List[int]:
    len_a, len_b = len(A), len(B)
    C = [0] * (len_a + len_b)

    i = j = k = 0
    while i < len_a and j < len_b:
        if A[i] <= B[j]:
            C[k] = A[i]
            i += 1
        else:
            C[k] = B[j]
            j += 1
        k += 1
      
    while i < len_a:
        C[k] = A[i]
        i += 1
        k += 1

    while j < len_b:
        C[k] = B[j]
        j += 1
        k += 1

    return C

总结：以上介绍了两种实现就地合并排序的方法：逆向扫描和正向扫描。两种方法都可实现就地排序，方法一适用于数组容量预留充足的情况，而方法二则适用于非常量空间预留的情况下。