# 0088. Merge Sorted Array

{% tabs %}
{% tab title="❓ Problem Statement" %}

> Source: [LeetCode - Merge Sorted Array](https://leetcode.com/problems/merge-sorted-array/)\
> GitHub: [Solution / Performance](https://github.com/yylou/leetcode/tree/main/0088-merge-sorted-array)

You are given two integer arrays `nums1` and `nums2`, sorted in **non-decreasing order**, and two integers `m` and `n`, representing the number of elements in `nums1` and `nums2` respectively.

**Merge** `nums1` and `nums2` into a single array sorted in **non-decreasing order**.

The final sorted array should not be returned by the function, but instead be ***stored inside the array***** `nums1`**. To accommodate this, `nums1` has a length of `m + n`, where the first `m` elements denote the elements that should be merged and the last `n` elements are set to `0` and should be ignored. `nums2` has a length of `n`.
{% endtab %}

{% tab title="✍🏻 Constraints & Example" %}
**Constraints:**

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

```
Input: nums1 = [1,2,3,0,0,0], m = 3, nums2 = [2,5,6], n = 3
Output: [1,2,2,3,5,6]
Explanation: The arrays we are merging are [1,2,3] and [2,5,6].
The result of the merge is [1,2,2,3,5,6] with the underlined elements coming from nums1.

Input: nums1 = [1], m = 1, nums2 = [], n = 0
Output: [1]
Explanation: The arrays we are merging are [1] and [].
The result of the merge is [1].

Input: nums1 = [0], m = 0, nums2 = [1], n = 1
Output: [1]
Explanation: The arrays we are merging are [] and [1].
The result of the merge is [1].
Note that because m = 0, there are no elements in nums1. The 0 is only there to ensure the merge result can fit in nums1.
```

{% endtab %}
{% endtabs %}

{% tabs %}
{% tab title="💡 Ideas" %}
**Three-pointer** is required for **placing numbers reversely** from the end of array1:

1. **place-pointer**: starting from the end, which value is `m + n - 1`.
2. **array1-pointer**: starting from the last element in array 1.
3. **array2-pointer**: starting from the last element in array 2.

**Note** that since the above pointers move forward (**index is decreasing** in each iteration), if array2-pointer reaches the beginning `p2 < 0`, we could return directly because array1 is already sorted correctly. On the other hand, we **also need to check whether array1-pointer reaches the beginning** by `p1 >= 0`.
{% endtab %}
{% endtabs %}

{% tabs %}
{% tab title="🤖 Python3" %}

```python
class Solution:
    def merge(self, nums1: List[int], m: int, nums2: List[int], n: int) -> None:
        #  (base case)
        if n == 0: return
        if m == 0: 
            for i in range(n): nums1[i] = nums2[i]
        
        # ==================================================
        #  Array + Three Pointers        (Start from End)  =
        # ==================================================        
        # time  : O(m+n)
        # space : O(1)
        
        p1, p2, placeP = m - 1, n - 1, m + n - 1
        while placeP >= 0:
            if p2 < 0: return
            
            if p1 >= 0 and nums1[p1] >= nums2[p2]:
                nums1[placeP] = nums1[p1]
                p1 -= 1
            else:
                nums1[placeP] = nums2[p2]
                p2 -= 1
                
            placeP -= 1
```

{% endtab %}

{% tab title="🤖 Java" %}

```java
class Solution {
    /**  
     * @time  : O(m+n)
     * @space : O(1)
     */

    public void merge(int[] nums1, int m, int[] nums2, int n) {
        /* base case */
        if(n == 0) return;
        if(m == 0) {
            for(int i=0 ; i<n ; i++) nums1[i] = nums2[i];
            return;
        }
        
        int p1 = m - 1, p2 = n - 1, placeP = m + n - 1;
        while(placeP >= 0) {
            if(p2 < 0) return;
            
            if(p1 >= 0 && nums1[p1] >= nums2[p2]) {
                nums1[placeP] = nums1[p1];
                p1--;
            } else {
                nums1[placeP] = nums2[p2];
                p2--;
            }
            
            placeP--;
        }
    }
}
```

{% endtab %}
{% endtabs %}