LeetCode面试150——88合并两个有序数组

LeetCode面试150——88合并两个有序数组

题目难度：简单

默认优化目标：最小化平均时间复杂度。

Python默认为Python3。

1 题目描述

给你两个按 非递减顺序 排列的整数数组 nums1 和 nums2，另有两个整数 m 和 n ，分别表示 nums1 和 nums2 中的元素数目。

请你 合并 nums2 到 nums1 中，使合并后的数组同样按 非递减顺序 排列。

注意：最终，合并后数组不应由函数返回，而是存储在数组 nums1 中。为了应对这种情况，nums1 的初始长度为 m + n，其中前 m 个元素表示应合并的元素，后 n 个元素为 0 ，应忽略。nums2 的长度为 n 。

示例 1：

输入：nums1 = [1,2,3,0,0,0], m = 3, nums2 = [2,5,6], n = 3
输出：[1,2,2,3,5,6]
解释：需要合并 [1,2,3] 和 [2,5,6] 。
合并结果是 [1,2,2,3,5,6] ，其中斜体加粗标注的为 nums1 中的元素。

示例 2：

输入：nums1 = [1], m = 1, nums2 = [], n = 0
输出：[1]
解释：需要合并 [1] 和 [] 。
合并结果是 [1] 。

示例 3：

输入：nums1 = [0], m = 0, nums2 = [1], n = 1
输出：[1]
解释：需要合并的数组是 [] 和 [1] 。
合并结果是 [1] 。
注意，因为 m = 0 ，所以 nums1 中没有元素。nums1 中仅存的 0 仅仅是为了确保合并结果可以顺利存放到 nums1 中。

提示：

• nums1.length == m + n

• nums2.length == n

• 0 <= m, n <= 200

• 1 <= m + n <= 200

• -109 <= nums1[i], nums2[j] <= 109

进阶：你可以设计实现一个时间复杂度为 O(m + n) 的算法解决此问题吗？

2 题目解析

输入是两个非递减排序的数组，输出是合并这两个数组后的非递减排序的数组。

从输入输出来看，必然涉及到数组的合并操作、排序操作。其中，排序操作是对时间复杂度影响最大的。

注意输入的数组已经是按非递减排序好了的，要降低算法的时间复杂度可以从这入手。用双指针就是个不错的选择，因为有两个非递减排序的数组。

从注意中看，要求用nums1返回结果。另外，nums1的初始长度为m+n，m是nums1中应该合并的元素个数，n为nums1中元素为零的个数，也是nums2的长度。

3 算法原理及程序实现

3.1 先合并后排序

直接将两个数组合并在一起，然后再排序。时间复杂度等于所选用排序算法的时间复杂度。例如使用快排，则平均时间复杂度为O((m+n)\log(m+n))，平均空间复杂度为O(\log(m+n))​

C++代码实现

class Solution {
public:
    void merge(vector<int>& nums1, int m, vector<int>& nums2, int n) {
        for(int i=0;i<n;i++){
            nums1[m+i]=nums2[i];
        }
        sort(nums1.begin(),nums1.end());
    }
};

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.
        """
        nums1[m:]=nums2
        nums1.sort()

3.2 双指针

题目描述中的非递减排序还没用到。我们可以使用双指针方法。一个指针指向nums1的第一个元素，另一个指针指向nums2的第一个元素。这样依次取数组中的元素，存入一个中间数组中，最后再更新nums1就行了。平均时间复杂度为O(m+n)，平均空间复杂度为O(m+n)。

C++代码实现

class Solution {
public:
    void merge(vector<int>& nums1, int m, vector<int>& nums2, int n) {
        int pointer1=0,pointer2=0;//指针，1指向nums1，2指向nums2
        int temp[m+n];//中间数组
        int cur;//接收指针指向元素的更小的那个值
​
        while(pointer1<m ||pointer2<n){//两个数组都都读完才停止循环
            if(pointer1==m){//nums1读完，接着读nums2
                cur=nums2[pointer2++];
            }else if(pointer2==n){//nums2读完，接着读nums1
                cur=nums1[pointer1++];
            }else if(nums1[pointer1]<nums2[pointer2]){//nums1中指向的元素比nums2中指向的小，nums1先放入
                cur=nums1[pointer1++];
            }else{//否则，nums2先放
                cur=nums2[pointer2++];
            }
            temp[pointer1+pointer2-1]=cur;//给中间数组赋值
        }
        for(int i=0;i<m+n;i++){
            nums1[i]=temp[i];//用中间数组更新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.
        """
        pointer1,pointer2=0,0
        temp=[]
​
        while pointer1<m or pointer2<n:
            if pointer1 == m:
                temp.append(nums2[pointer2])
                pointer2+=1
            elif pointer2 == n:
                temp.append(nums1[pointer1])
                pointer1+=1
            elif nums1[pointer1]<nums2[pointer2]:
                temp.append(nums1[pointer1])
                pointer1+=1
            else:
                temp.append(nums2[pointer2])
                pointer2+=1
            
        nums1[:]=temp
​
​

3.3 逆向双指针

进一步，nums1的长度为m+n，也就是说后面有n个空余位置。我们能不能利用这些空余位置，从而节省开辟中间数组的存储空间呢？

我们假设一个极端情况，先全部放nums2中的元素，即nusm2中的最大的元素比nums1中最小的元素小。那就是说，nums2中的n个元素。如果我们从后面放，刚好填满空闲位置。只要把指针的位置从指向数组的第一个元素改为指向数组的非零值的最后一个元素，就可以不用中间数组来存放元素值了。

将双指针的代码稍加修改即可实现功能。因为逆向，所以运算全部要反过来。++变--，<变>。指针指向也从0分别变为m-1，n-1。

平均时间复杂度O(m+n)，平均空间复杂度O(1)。

C++代码实现

class Solution {
public:
    void merge(vector<int>& nums1, int m, vector<int>& nums2, int n) {
        int pointer1=m-1,pointer2=n-1;//指针，1指向nums1的末尾，2指向nums2末尾
        int cur;//接收指针指向元素的更小的那个值
        int tail=m+n-1;
​
        while(pointer1>=0 ||pointer2>=0){//两个数组都都读完才停止循环
            if(pointer1==-1){//nums1读完，接着读nums2
                cur=nums2[pointer2--];
            }else if(pointer2==-1){//nums2读完，接着读nums1
                cur=nums1[pointer1--];
            }else if(nums1[pointer1]>nums2[pointer2]){//nums1中指向的元素比nums2中指向的大，nums1先放入
                cur=nums1[pointer1--];
            }else{//否则，nums2先放
                cur=nums2[pointer2--];
            }
            nums1[tail--]=cur;
        }
       
​
    }
};

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.
        """
        pointer1,pointer2=m-1,n-1
        tail=m+n-1
        
​
        while pointer1>=0 or pointer2>=0:
            if pointer1 == -1:
                nums1[tail]=nums2[pointer2]
                pointer2-=1
            elif pointer2 == -1:
                nums1[tail]=nums1[pointer1]
                pointer1-=1
            elif nums1[pointer1]>nums2[pointer2]:
                nums1[tail]=nums1[pointer1]
                pointer1-=1
            else:
                nums1[tail]=nums2[pointer2]
                pointer2-=1
            
            tail-=1
​
​

参考资料

力扣面试经典150题

力扣官方题解