Title Description

Give you two integer arrays nums1 and nums2 in non decreasing order, and two integers m and n, representing the number of elements in nums1 and nums2 respectively. Please merge nums2 into nums1 so that the merged array is also arranged in non decreasing order.

Title Example

• Example 1:

Input: nums1 = [1,2,3,0,0,0], m = 3, nums2 = [2,5,6], n = 3
 Output:[1,2,2,3,5,6]
Explanation: consolidation required [1,2,3] and [2,5,6] . 
The combined result is [1,2,2,3,5,6] ，Where bold italics indicates nums1 Elements in.

• Example 2:

Input: nums1 = [1], m = 1, nums2 = [], n = 0
 Output:[1]
Explanation: consolidation required [1] and [] . 
The combined result is [1] . 

• Example 3:

Input: nums1 = [0], m = 0, nums2 = [1], n = 1
 Output:[1]
Explanation: the array to be merged is [] and [1] . 
The combined result is [1] . 
Attention, because m = 0 ，therefore nums1 There are no elements in the. nums1 The only remaining 0 is to ensure that the consolidated results can be saved to the nums1 Yes.

• Tips:

nums1.length == m + n
nums2.length == n
0 <= m, n <= 200
1 <= m + n <= 200
-10^9 <= nums1[i], nums2[j] <= 10^9

Java method: sort after direct merge

Ideas and algorithms

The most intuitive method is to put array nums2 into the tail of array nums1, and then sort the whole array directly.

code

class Solution {
    public void merge(int[] nums1, int m, int[] nums2, int n) {
        for (int i = 0; i != n; ++i) {
            nums1[m + i] = nums2[i];
        }
        Arrays.sort(nums1);
    }
}

results of enforcement

• Execution result: passed
• Execution time: 1 ms, beating 17.63% of users in all Java submissions
• Memory consumption: 38.3 MB, beating 81.72% of users in all Java submissions

Complexity

• Time complexity: O((m+n)log(m+n))
• Spatial complexity: O(log(m+n))

Java method: double pointer

Ideas and algorithms

You can use the double pointer method. In this method, two arrays are regarded as queues, and smaller numbers are taken from the heads of the two arrays each time and put into the results. Set a pointer p1 and p2 for the two arrays as the head pointer of the queue.

code

class Solution {
    public void merge(int[] nums1, int m, int[] nums2, int n) {
        int p1 = 0, p2 = 0;
        int[] sorted = new int[m + n];
        int cur;
        while (p1 < m || p2 < n) {
            if (p1 == m) {
                cur = nums2[p2++];
            } else if (p2 == n) {
                cur = nums1[p1++];
            } else if (nums1[p1] < nums2[p2]) {
                cur = nums1[p1++];
            } else {
                cur = nums2[p2++];
            }
            sorted[p1 + p2 - 1] = cur;
        }
        for (int i = 0; i != m + n; ++i) {
            nums1[i] = sorted[i];
        }
    }
}

results of enforcement

• Execution result: passed
• Execution time: 0 ms, beating 100.00% of users in all Java submissions
• Memory consumption: 38.5 MB, beating 58.52% of users in all Java submissions

Complexity

• Time complexity: O(m+n)
• Space complexity: O(m+n)

Java method: reverse double pointer

Ideas and algorithms

The second half of nums1 is empty and can be directly overwritten without affecting the result. Therefore, the pointer can be set to traverse from back to front, taking the larger of the two each time and putting it at the back of nums1. Strictly speaking, at any time in the traversal process, m − p1 − 1 elements in the nums1 array are placed in the latter half of nums1, n − p2 − 1 elements in the nums2 array are placed in the latter half of nums1, and after the pointer p1, the nums1 array has m+n − p1 − 1 positions. Because m+n − p1
− 1 ≥ m − p1 − 1+n − p2 − 1 is equivalent to that p2 ≥ − 1 is always established. Therefore, the position behind p1 is always enough to accommodate the inserted elements, and the element of p1 will not be covered.

code

class Solution {
    public void merge(int[] nums1, int m, int[] nums2, int n) {
        int p1 = m - 1, p2 = n - 1;
        int tail = m + n - 1;
        int cur;
        while (p1 >= 0 || p2 >= 0) {
            if (p1 == -1) {
                cur = nums2[p2--];
            } else if (p2 == -1) {
                cur = nums1[p1--];
            } else if (nums1[p1] > nums2[p2]) {
                cur = nums1[p1--];
            } else {
                cur = nums2[p2--];
            }
            nums1[tail--] = cur;
        }
    }
}

results of enforcement

• Execution result: passed
• Execution time: 0 ms, beating 100.00% of users in all Java submissions
• Memory consumption: 38.6 MB, beating 31.81% of users in all Java submissions

Complexity

• Time complexity: O(m+n)
• Space complexity: O(1)