I can't understand the example test case for Merge Sorted Array?

Input: [0] 0 [1] 1 Expected: [1]

The 0 is m and the 1 is n where m is the number of elements in the first array and n is the number of elements in the second array.

Thus, the first array does not contain the element 0. In fact, it contains no elements at all (0). The [0] in the first array is actually a placeholder for the elements to be merged (since the size of the first array is supposed to be (m+n). So merging them would give an output [1] which is just the element of the second array merged into the first.

Here is my code for the problem:

class Solution {
    public void merge(int[] nums1, int m, int[] nums2, int n) {
        int mPtr = m - 1;
        int nPtr = n - 1;
        int index = nums1.length - 1;
        while (nPtr >= 0) {
            if (mPtr >= 0 && nums1[mPtr] >= nums2[nPtr]) {
                nums1[index--] = nums1[mPtr--];
            } else {
                nums1[index--] = nums2[nPtr--];
            }
        }
    }
}

Given two sorted integer arrays nums1 and nums2, merge nums2 into nums1 as one sorted array.

The number of elements initialized in nums1 and nums2 are m and n respectively. You may assume that nums1 has enough space (size that is equal to m + n) to hold additional elements from nums2.

I'm posting solution in Python.

Please find the code.

Analysis- Just check for zeros in first list and then replace with element in second list. If either of the list is empty, just print list 1.

def merge(nums1, m, nums2, n):

a=len(nums1)
i=0
j=0
while i< a:
    if n  == 0 or m==0 :
        return nums1
    if nums1[i]==0:
        nums1[i]=nums2[j]
        j+=1
    i+=1
return sorted(nums1)

I have the solution in c++

class Solution {
public:
    void merge(vector<int>& nums1, int m, vector<int>& nums2, int n) {        
    int i = m - 1;
    int j = n - 1;
    int 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--];
}
    
        
    
};

Basically it uses divide and conquer algorithm that repeatedly splits an array into halves, sorts each half, and then merges the sorted halves into a single sorted array. Make sure the formula for finding mid is MId=STARTINDEX + (ENDINDEX - STARTINDEX)/2 it cause space complexity

import java.util.*
public class main {

    public static void mergeSort(int[] arr, int left, int right) {
        if (left < right) {
            int mid = left + (right - left) / 2;
            mergeSort(arr, left, mid);
            mergeSort(arr, mid + 1, right);
            merge(arr, left, mid, right);
        }
    }

    public static void merge(int[] arr, int left, int mid, int right) {
        int n1 = mid - left + 1;
        int n2 = right - mid;

        int[] L = new int[n1];
        int[] R = new int[n2];

        for (int i = 0; i < n1; i++)
            L[i] = arr[left + i];
        for (int j = 0; j < n2; j++)
            R[j] = arr[mid + 1 + j];

        int i = 0, j = 0, k = left;

        while (i < n1 && j < n2) {
            if (L[i] <= R[j]) {
                arr[k] = L[i];
                i++;
            } else {
                arr[k] = R[j];
                j++;
            }
            k++;
        }

        while (i < n1) {
            arr[k] = L[i];
            i++;
            k++;
        }

        while (j < n2) {
            arr[k] = R[j];
            j++;
            k++;
        }
    }

    public static void printArray(int[] arr) {
        for (int num : arr)
            System.out.print(num + " ");
        System.out.println();
    }

    public static void main(String[] args) {
        int[] arr = { 12, 11, 13, 5, 6, 7 };
        System.out.println("Given Array:");
        printArray(arr);

        mergeSort(arr, 0, arr.length - 1);

        System.out.println("Sorted Array:");
        printArray(arr);
    }
}