合并两个具有O(1)额外空间的排序数组

合并两个有序数组是经典的排序问题，通常的做法是使用额外的空间，比如创建一个新的数组或者使用链表等数据结构。但是，在某些情况下，我们需要在一个固定的空间范围内完成该操作，因为额外的空间可能会非常有限，比如在嵌入式系统中。下面介绍几种可以在O(1)额外空间的情况下合并两个有序数组的算法。

算法一：交替合并

我们可以使用双指针的方式，分别从两个数组的起始位置开始遍历，比较两个指针所指的元素，将较小的元素放入一个新数组的下一个位置，然后移动指向较小元素的指针，重复这个过程直到一个数组的所有元素都被遍历完。最后，将剩余的另一个数组依次复制到新数组的末尾即可。

def merge(nums1: List[int], m: int, nums2: List[int], n: int) -> None:
    """
    :type nums1: List[int]
    :type m: int
    :type nums2: List[int]
    :type n: int
    :rtype: None Do not return anything, modify nums1 in-place instead.
    """
    i, j, k = m - 1, n - 1, m + n - 1
    while i >= 0 and j >= 0:
        if nums1[i] > nums2[j]:
            nums1[k] = nums1[i]
            i -= 1
        else:
            nums1[k] = nums2[j]
            j -= 1
        k -= 1
    while j >= 0:
        nums1[k] = nums2[j]
        j -= 1
        k -= 1

上面的算法时间复杂度为O（m+n），实现比较简单。

算法二：二分查找

我们可以通过二分查找的方式，在第一个数组中查找一个位置，使得该位置将第二个数组中的元素划分为两部分，其中左边的元素都小于等于右边的元素，然后再在第二个数组中查找一个位置，使得该位置将第一个数组中的元素划分为两部分，其中左边的元素都小于等于右边的元素。然后将左边和右边的两部分依次合并即可。

def merge(nums1: List[int], m: int, nums2: List[int], n: int) -> None:
    """
    :type nums1: List[int]
    :type m: int
    :type nums2: List[int]
    :type n: int
    :rtype: None Do not return anything, modify nums1 in-place instead.
    """
    def binary_search(nums, size, target):
        left, right = 0, size - 1
        while left <= right:
            mid = (left + right) // 2
            if nums[mid] == target:
                return mid
            elif nums[mid] < target:
                left = mid + 1
            else:
                right = mid - 1
        return left

    i, j = 0, 0
    while j < n:
        position = binary_search(nums1, m + j, nums2[j])
        nums1[position+1:m+j+1] = nums1[position:m+j]
        nums1[position] = nums2[j]
        j += 1
    return nums1

上面的算法时间复杂度可达到O（nlogm），由于涉及到数组的复制，所以可能不适合实际应用，但它可以对我们理解合并算法很有帮助。

小结

上面介绍了两种可以在O(1)额外空间的情况下合并两个有序数组的算法，第一种简单易懂，但时间复杂度较高；第二种时间复杂度更低，但实现比较麻烦。在实际应用时，我们需要根据实际情况选择适合的算法，可以根据数据规模和内存限制来决定。