Вот шаги для решения этой проблемы:

  • Мы начинаем с инициализации 3 указателей, i, j и k, которые будут использоваться для обхода массивов nums1 и nums2.
  • i начинается с m - 1, так как nums1 имеет m элементов, и нам нужно сравнить элементы с конца nums1.
  • j начинается с n - 1, так как nums2 имеет n элементов, и нам нужно сравнить элементы с конца nums2.
  • k начинается с m + n - 1, так как результирующий массив nums1 имеет m + n элементов, и нам нужно начать с конца nums1.
  • В первом цикле while мы сравниваем элементы в конце nums1 и nums2 и помещаем больший из двух в конец nums1.
  • Во втором цикле while мы добавляем все оставшиеся элементы nums2 в конец nums1.

Вот решение на Python:

class Solution:
    def merge(self, nums1: List[int], m: int, nums2: List[int], n: int) -> 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]
            k -= 1
            j -= 1

Вот то же решение в Javascript

var merge = function(nums1, m, nums2, n) {
    let i = m - 1, j = n - 1, k = m + n - 1;
    while (i >= 0 && j >= 0) {
        if (nums1[i] >= nums2[j]) {
            nums1[k] = nums1[i];
            i--;
        } else {
            nums1[k] = nums2[j];
            j--;
        }
        k--;
    }
    while (j >= 0) {
        nums1[k] = nums2[j];
        k--;
        j--;
    }
};

Временная сложность приведенных выше решений составляет O(m + n):.

  • Два цикла while выполняются не более m + n раз. В худшем случае по одному элементу из каждого из массивов nums1 и nums2 сравнивается и добавляется к nums1 на каждой итерации.
  • Следовательно, временная сложность решения равна O(m + n).

Пространственная сложность приведенных выше решений равна O(1):.

  • Решение изменяет массив nums1 на месте и не требует никаких дополнительных структур данных.
  • Объемная сложность решения составляет O(1), так как решение использует только несколько переменных для указателей.