合并数组ab

题目：数组A和数组B均有序，数组A有足够大内存来容纳数组B，将数组B有序合并到数组A中

分析：如果由前至后合并，复杂度将会是O(N2)，这样的复杂度显然不是最优解，利用两个指针指向两个数组的尾部，从后往前遍历，这样的复杂度为O(n2)

所以很快可以写出下面的代码：

[cpp] view plaincopy

1. #include <iostream>  
2. #include <algorithm>  
3. #include <iterator>  
4.   
5. using namespace std;  
6.   
7. int arrayA[10] = {1, 3, 5, 7, 9};  
8. int arrayB[] = {2, 4, 6, 8, 10};  
9. const int sizeB = sizeof arrayB / sizeof *arrayB;  
10. const int sizeA = sizeof arrayA / sizeof *arrayA - sizeB;  
11.   
12. int* mergeArray(int *arrayA, int sizeA, int *arrayB, int sizeB)  
13. {  
14.     if (arrayA == NULL || arrayB == NULL || sizeA < 0 || sizeB < 0)  
15.         return NULL;  
16.   
17.     int posA = sizeA - 1;  
18.     int posB = sizeB - 1;  
19.   
20.     while (posA >= 0 && posB >= 0)  
21.     {  
22.         if (arrayA[posA] < arrayB[posB])  
23.         {  
24.             arrayA[posA + posB + 1] = arrayB[posB];  
25.             posB--;  
26.         }  
27.         else  
28.         {  
29.             arrayA[posA + posB + 1] = arrayA[posA];  
30.             posA--;  
31.         }  
32.         copy(arrayA, arrayA + 10, ostream_iterator<int>(cout, " "));  
33.         system("pause");  
34.     }  
35.   
36.     return arrayA;  
37. }  
38.   
39. void main()  
40. {  
41.     int *result = mergeArray(arrayA, sizeA, arrayB, sizeB);  
42.   
43.     copy(result, result + 10, ostream_iterator<int>(cout, " "));  
44.     cout << endl;  
45. }  

代码写完后似乎完成了所需功能，但还不止于此，必须对上述代码做UT

1. 健壮性

arrayA或arrayB为空，长度小于0

2. 边界用例

arrayA为空，长度为1；arrayB不为空，长度大于1

首元素用例

const int size = 6;

int arrayA[size] = {2};
int arrayB[] = {0, 1, 1, 1, 1};

反之

const int size = 6;
int arrayA[size] = {0, 1, 1, 1, 1};
int arrayB[] = {2};

3. 正常用例：

const int size = 10;
int arrayA[size] = {1, 3, 5, 7, 9};
int arrayB[] = {2, 4, 6, 8, 10};

const int size = 10;
int arrayA[size] = {2, 4, 6, 8, 10};
int arrayB[] = {1, 3, 5, 7, 9};

const int size = 10;
int arrayA[size] = {1, 2, 3, 4, 5};
int arrayB[] = {6, 7, 8, 9, 10};

const int size = 10;
int arrayA[size] = {6, 7, 8, 9, 10};
int arrayB[] = {1, 2, 3, 4, 5};

经过上面的测试，不难发现在边界条件用例中，代码已经不能正确运行出结果，在测试用例的驱动下，不难写出正确代码

[cpp] view plaincopy

1. int* mergeArray(int *arrayA, int sizeA, int *arrayB, int sizeB)  
2. {  
3.     if (arrayA == NULL || arrayB == NULL || sizeA < 0 || sizeB < 0)  
4.         return NULL;  
5.   
6.     int posA = sizeA - 1;  
7.     int posB = sizeB - 1;  
8.   
9.     while (posA >= 0 && posB >= 0)  
10.     {  
11.         if (arrayA[posA] < arrayB[posB])  
12.         {  
13.             arrayA[posA + posB + 1] = arrayB[posB];  
14.             posB--;  
15.         }  
16.         else  
17.         {  
18.             arrayA[posA + posB + 1] = arrayA[posA];  
19.             posA--;  
20.         }  
21.         copy(arrayA, arrayA + size, ostream_iterator<int>(cout, " "));  
22.         system("pause");  
23.     }  
24.   
25.     //出现两种情形：  
26.     //1. posA < 0 && posB >= 0  
27.     //2. posA >= 0 && posB < 0  
28.     //只有第1种情形需要进行处理  
29.     if (posA < 0 && posB >= 0)  
30.     {  
31.         while (posB >= 0)  
32.         {  
33.             arrayA[posA + posB + 1] = arrayB[posB];  
34.             posB--;  
35.         }  
36.     }   
37.   
38.     return arrayA;  
39. }