剑指Offer 合并两个有序数组 C++实现

题目描述
给出两个有序的整数数组A和B ，请将数组B 合并到数组A 中，A变成一个有序的数组
注意：
可以假设A 数组有足够的空间存放B 数组的元素，A 和B 中初始的元素数目分别为m 和 n

解法
解法一：最笨的解法。创建一个新数组C，比较A和B中的元素，哪个小就将该元素放入C中，最后将C数组元素放回A中。

class Solution {
public:
    void merge(int A[], int m, int B[], int n) {
        int i = 0, j = 0;
        if(n == 0) return;
        if(m == 0) 
        {
            for(j = 0; j < n; j++)
            {
                A[i] = B[j];
                i++;
            }
            return;
        }
        
        int k;
        int C[m + n];
       
        //put sorted elements in a new array C[]
        for(k = 0; k < m + n; k++)
        {
            if(i < m && j < n){
                if(A[i] <= B[j])
                {
                    C[k] = A[i];
                    i++;
                }
                else
                {
                    C[k] = B[j];
                    j++;
                }
                continue;
            }
            else{
                if(i == m)
                {
                    C[k] = B[j];
                    j++;
                    continue;
                }
                if(j == n)
                {
                    C[k] = A[i];
                    i++;
                    continue;
                }
            }
            
        }
        
        //put elements in array C[] to array A[]
        k = 0;
        for(i = 0; i < m + n; i++)
        {
            A[i] = C[k];
            k++;
        }
        
    }
};

时间复杂度O(m+n)
空间复杂度O(m+n)

**解法二：**从后往前处理,不需要开辟额外空间。
如果从前往后处理，会有大量的元素移动，造成时间浪费，但从后往前可以避免大量元素移动。
一定要注意数组下标是否越界！
循环条件：A，B都未处理完；若A已处理完，要将B元素依次放入，若B已处理完，则不用管。

class Solution {
public:
    void merge(int A[], int m, int B[], int n) {
        int i = 0, j = 0;
        if(n == 0) return;
        if(m == 0) 
        {
            for(j = 0; j < n; j++)
            {
                A[i] = B[j];
                i++;
            }
            return;
        }
        
        // 分别记录A,B的最右边位置
        i = m-1;
        j = n-1;
        // A,B合并后的数组的下标
        int index = m + n -1;
        
        while(j >= 0 && i >= 0)
        {
            if(A[i] >= B[j])
            {
                A[index] = A[i];
                i--;
            }
            else 
            {
                A[index] = B[j];
                j--;
            }
            index--;
        }
        if(i < 0)
        {
            while(j >= 0)
            {
                A[index] = B[j];
                j--;
                index--;
            }
        }
    }

};

时间复杂度O(m+n)
空间复杂度O(1)