leetcode_88. 合并两个有序数组

leetcode_88. 合并两个有序数组

leetcode原题链接

题目描述

给你两个按 非递减顺序 排列的整数数组 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 中的元素。
1
2
3
4

示例 2：

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

示例 3：

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

提示：

• nums1.length == m + n
• nums2.length == n
• 0 <= m, n <= 200
• 1 <= m + n <= 200
• -109 <= nums1[i], nums2[j] <= 109

题解：

方法一: 双指针

由于nums1[]和nums2[]本身已经是 有序数组了, 我们可以先创建一个新数组res[], 然后定义两个指针i, j去遍历nums1[]和nums2[], 每次比较i和j指向的数组元素的大小, 并且将小的那个添加到res[]数组, 然后将指针向后移动一个

• 如果nums1[i] < nums2[j], 那么就将nums1[i]添加到res[]中, 然后将i指针向后移动一位
• 否则, 就将nums2[j]添加到res[]中, 然后将j指针向后移动一位
• 直到nums1[], nums2[]其中的一个遍历结束
• 最后将没有遍历完的那个数组中后面剩余的元素复制到res[]中

分析: 这种做法简单直接, 时间负责度是$O(n)$级别的, 缺点创建了一个新的数组存储结果, 空间负责的也是$O(n)$.

Java

class Solution {
    public void merge(int[] nums1, int m, int[] nums2, int n) {
        int i = 0, j = 0, k = 0;
        int[] res = new int[m + n];
        while (i < m && j < n) {
            if (nums1[i] < nums2[j]) res[k++] = nums1[i++];
            else res[k++] = nums2[j++];
        }
        while (i < m) res[k++] = nums1[i++];
        while (j < n) res[k++] = nums2[j++];
        for (int t = 0; t < m + n; t++ ) 
            nums1[t] = res[t];
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

C++

class Solution {
public:
    void merge(vector<int>& nums1, int m, vector<int>& nums2, int n) {
        int i = 0, j = 0, k = 0;
        int res[m + n];
        while (i < m && j < n) {
            if (nums1[i] < nums2[j]) res[k++] = nums1[i++];
            else res[k++] = nums2[j++];
        }
        while (i < m) res[k++] = nums1[i++];
        while (j < n) res[k++] = nums2[j++];
        for (int t = 0; t < m + n; t++ ) 
            nums1[t] = res[t];
    }
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

方法二:逆向双指针

有没有办法不创建新的数组直接在原数组上操作并存储我们的结果呢? 题中说nums1的实际长度是m + n, 前m个位置存的是实际的数据, 后面n个位置都是0, 那么我们就要想办法将后面的空间利用起来.

如果我们还是采取上面从左往右遍历的话, 那么为了存储我们的结果, 必然要将nums1中的数据向后移动, 如果每次都移动的话, 那么我们算法的时间负责度就会来到$O(n)$级别, 这时我们就要采取别的方式了

因为nums后面的空间是空闲的, 那么我们完全可以逆向的遍历nums1和nums2中的数据, 每次得到一个最大的, 放到nums1的末尾, 这样就不需要在存储结果的时候移动数组元素了. 从后往前依次得到最大的数, 完全等效于从前往后依次得到最小的.

此时产生了一个新的问题, nums1末尾的空间有$n$个, 当我们的结果超过$n$之后会发生什么事情呢, 会不会因为我们每次都把结果放在后面而覆盖前面的有效数据呢?

我们假设当我们把这$n$个空间都用完的时候, 我们已经从nums1中取出来$a$个数据, 从nums2中取出来$b$个数据了, 那么其实我们这时存放结果的空间已经从$n$变成了$n+a$, 因为nums1后面$a$个数据已经被取出, 没有任何意义了, 它们早就已经存到我们的结果里了. 所以我们每从nums1中取出结果添加到nums末端时, 我们可以存储结果的空间是不会变的. 而当我们从nums2中取到结果时, 我们实际可以存放结果的空间才会减少一个.

综上, 在我们从后往前遍历两个数组, 并将结果添加到nums1中的时候, 完全不用担心后面的空间不够用覆盖前面的有效数据的问题.

最后, 如果nums2数组先遍历完, 那么nums1中剩余的没有遍历的也肯定已经在它们正确的位置上了, 因为如果它们最后被剩下来, 那么它们一定是最小的, 就应该放在最前面. 如果nums1先遍历完, 那么我们只需要把nums2中剩余的全都复制到nums1中即可,

java

class Solution {
    public void merge(int[] nums1, int m, int[] nums2, int n) {
        int i = m - 1, j = n - 1, k = m + n - 1;
        while (i >= 0 && j >= 0) {
            if (nums1[i] > nums2[j]) nums1[k--] = nums1[i--];
            else nums1 [k--] = nums2[j--];
        }
        while (j >= 0) nums1[k--] = nums2[j--];
    }
}
1
2
3
4
5
6
7
8
9
10

C++

class Solution {
public:
    void merge(vector<int>& nums1, int m, vector<int>& nums2, int n) {
        int i = m - 1, j = n - 1, k = m + n - 1;
        while (i >= 0 && j >= 0) {
            if (nums1[i] > nums2[j]) nums1[k--] = nums1[i--];
            else nums1[k--] = nums2[j--];
        }
        while (j >= 0) nums1[k--] = nums2[j--];
    }
};
1
2
3
4
5
6
7
8
9
10
11

可以看到, 我们的代码在降低了空间复杂度的同时, 还变得更简洁了.