Leetcode OJ: Merge Sorted Array

Merge Sorted Array

Given two sorted integer arrays A and B, merge B into A as one sorted array.

Note:
You may assume that A has enough space (size that is greater or equal to m + n) to hold additional elements from B. The number of elements initialized in A and B are m andn respectively.

最简单粗暴的思路：

1. 开辟数组空间C用以存放中间过程，然后对A、B数组各给一个指针。

2. 开始遍历比较，哪个小把对应的值push进C，然后对应指针也后移，直到两个数组都遍历完了。

3. 把C的值都拷贝到A。

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

代码如下：

class Solution {
public:
    void merge(int A[], int m, int B[], int n) {
        vector<int> C;
        int i = 0, j = 0;
        int count = 0;
        while (i < m && j < n) {
            if (A[i] < B[j]) {
                C.push_back(A[i]);
                ++i;
            } else {
                C.push_back(B[j]);
                ++j;
            }
            count++;
        }
        while (i < m) {
            C.push_back(A[i++]);
            count++;
        }
        while (j < n) {
            C.push_back(B[j++]);
            count++;
        }
        
        for (int i = 0; i < count; ++i) {
            A[i] = C[i];
        }
    }
};

减少比较次数的思路（利用二分查找）：

1. 开辟数组空间C用以存放中间过程，然后对A、B数组各给一个指针i, j。

2. 在A[i]后查找B[j]应该在A中插入的位置i+ansA（一定要注意好下标）

3. 若ansA没越界，判断A[i+ansA]是与B[j]是否相等，若相等重复3，否则跳下一步4。

4. 把A[i]~A[i+ansA](不包含)值都拷贝到C中。

5. 若ansA仍没越界，则在B[j]中查找这一值应插入的位置ansB，把B[j]~B[j+ansB]（不包含）值都拷贝到C中，j:=j+ansB。

6. i := i+ansA。如果i,j均没越界，跳到2，否则跳到下一步7。

7. 把A、B中的剩余部分都拷贝到C

8. 最后把C的值都拷贝到A

代码如下：

class Solution {
public:
    // 二分查找
    int search(int A[], int n, int target) {
        int begin = 0, end = n, mid;
        while (begin < end) {
            mid = begin + ((end - begin) >> 1);
            if (A[mid] < target) {
                begin = mid + 1;
            } else if (A[mid] > target) {
                end = mid;
            } else {
                break;
            }
        }
        if (begin >= end)
            return end;
        return mid;
    }

    void merge(int A[], int m, int B[], int n) {
        vector<int> C;
        int i = 0, j = 0;
        while (i < m && j < n) {
            int ansA = search(A + i, m - i, B[j]);
            // 判断是否与B[j]相等
            while (i + ansA < m && A[i + ansA] == B[j])
                ++ansA;
            if (ansA > 0)
                C.insert(C.end(), A + i, A + i + ansA);
            if (i + ansA < m) {
                int ansB = search(B + j, n - j, A[i + ansA]);
                if (ansB > 0) {
                    C.insert(C.end(), B + j, B + j + ansB);
                    j += ansB;
                }
            } 
            i += ansA;
        }
        if (i < m) {
            C.insert(C.end(), A + i, A + m);
        }
        if (j < n) {
            C.insert(C.end(), B + j, B + n);
        }
        
        copy(C.begin(), C.end(), A);
    }
};

比较次数是O(logm+logn)，复制次数还是O(m+n)，最终复杂度还是O(m+n)，空间复杂度为O(m+n)。

在时间复杂度上我已经尽力了，于是就想有没有空间复杂度为O(1)的方法呢？

很自然就会想到利用数组移动，为了减小移动的数量，我们还可以结合以上说到的二分查找。

过程与以上类似，只是中间过程需要不断改变A的长度，而且要特别的注意下标问题。

class Solution {
public:
    int search(int* A, int n, int target) {
        int begin = 0, end = n;
        int mid;
        while (begin < end) {
            mid = begin + ((end - begin) >> 1);
            if (A[mid] < target) {
                begin = mid + 1;
            } else if (A[mid] > target) {
                end = mid;
            } else {
                break;
            }
        }
        
        if (begin >= end) {
            return end;
        }
        return mid;
    }
    
    
    void merge(int A[], int m, int B[], int n) {
        vector<int> C;
        int i = 0, j = 0;
        while (i < m && j < n) {
            int ansA = search(A + i, m - i, B[j]);
            while (i + ansA < m && A[i + ansA] == B[j])
                ansA++;
            if (ansA < m - i) {
                int ansB = search(B + j, n - j, A[i + ansA]);
                if (ansB > 0) { 
                    for (int k = m - 1; k >= i + ansA; --k) {
                        A[k + ansB] = A[k];
                    }
                    for (int k = 0; k < ansB; ++k) {
                        A[i + ansA + k] = B[j + k];
                    }
                    j += ansB;
                }
                i += ansA + ansB;
                m += ansB;
            } else {
                i += ansA;
                break;
            }
        }
        
        while (j < n) {
            A[i++] = B[j++];
        }
    }
};

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

不过最终在LeetCode上跑的运行时间，对于这三段代码都是没有明显的区别，有时候简单粗暴的方法还更快一些。所以大家看着玩就好。