合并排序

前面一篇博客提到的快速排序是排序算法中的一种经典算法。和快速排序一样，合并排序是另外一种经常使用的排序算法。那么合并排序算法有什么不同呢？关键之处就体现在这个合并上面。
    合并算法的基本步骤如下所示：
    1）把0~length-1的数组分成左数组和右数组
    2）对左数组和右数组进行迭代排序
    3）将左数组和右数组进行合并，那么生成的整个数组就是有序的数据数组

    下面就开始实践操作：
    a）创建函数，判断参数的合法性

[cpp] view plain copy

1. void merge_sort(int array[], int length)  
2. {  
3.     if(NULL == array || 0 == length)  
4.         return ;  
5.     _merge_sort(array, 0, length-1);  
6. }  

    b）进行merge函数迭代操作

[cpp] view plain copy

1. void _merge_sort(int array[], int start, int end)  
2. {  
3.     if(start >= end)  
4.         return;  
5.   
6.     int middle = start + ((end - start) >> 1);  
7.     _merge_sort(array, start, middle);  
8.     _merge_sort(array, middle + 1, end);  
9.     _merge_data_in_array(array, start, middle, end);  
10. }  

     c）对合并后的队列进行合并操作

[cpp] view plain copy

1. void _merge_data_in_array(int array[], int start, int middle, int end)  
2. {  
3.     int length = end - start + 1;  
4.     int* pData = NULL;  
5.     int left = start;  
6.     int right = middle + 1;  
7.     int all = 0;  
8.   
9.     /* allocate new memory to the space */  
10.     pData = (int*) malloc(sizeof(int) * length);  
11.     assert(NULL != pData);  
12.     memset(pData, 0, length);  
13.   
14.     /* begin to move data */  
15.     while(right <= end){  
16.         while(array[left] <= array[right] && left <= middle){  
17.             pData[all] = array[left]; left ++; all ++;  
18.         }  
19.   
20.         if(left > middle)  {  
21.             break;  
22.         }  
23.   
24.         while(array[left] > array[right] && right <= end){  
25.             pData[all] = array[right]; right ++; all ++;  
26.         }  
27.     }  
28.   
29.     /* move the left data */  
30.     if(left <= middle)  
31.         memmove(&pData[all], &array[left], sizeof(int) * (middle -left +1));  
32.   
33.     if(right <= end)  
34.         memmove(&pData[all], &array[right], sizeof(int) * (end - right + 1));  
35.       
36.     memmove(&array[start], pData, sizeof(int) * length);  
37.     free(pData);  
38. }  

    注： 文中使用的pData动态内存不是一种最优的处理办法，实际开发中可以由其他形式的数据类型代替。

    d）编写测试用例

[cpp] view plain copy

1. static void test1()  
2. {  
3.     int array[] = {1};  
4.     merge_sort(array, sizeof(array)/sizeof(int));  
5. }  
6.   
7. static void test2()  
8. {  
9.     int array[] = {2, 1};  
10.     merge_sort(array, sizeof(array)/sizeof(int));  
11.     assert(1 == array[0]);  
12.     assert(2 == array[1]);  
13. }  
14.   
15. static void test3()  
16. {  
17.     int array[] = {3, 2, 1};  
18.     merge_sort(array, sizeof(array)/sizeof(int));  
19.     assert(1 == array[0]);  
20.     assert(2 == array[1]);  
21.     assert(3 == array[2]);  
22. }  
23.   
24. static void test4()  
25. {  
26.     int array[] = {4, 3, 5, 1};  
27.     merge_sort(array, sizeof(array)/sizeof(int));  
28.     assert(1 == array[0]);  
29.     assert(3 == array[1]);  
30.     assert(4 == array[2]);  
31.     assert(5 == array[3]);  
32. }  

分析快速排序和合并排序的相同点和不同点：
    相同点： 都是迭代操作
    不同点： 快速排序，先分类再迭代；合并排序，先迭代再合并