二路归并排序算法

将两个按值有序序列合并成一个按值有序序列，则称之为二路归并排序，下面有自底向上和自顶向下的两种排序算法，自顶向下的排序在本文末讲述，使用递归实现，代码较简洁，经供参考。

1. 归并子算法：把位置相邻的两个按值有序序列合并成一个按值有序序列。例如把序列 X[s..u] = {3, 12, 23, 32}和 序列 X[u+1..v] = {2, 5, 8, 99} 合并成序列 

Z[s..v] = {2, 3, 5, 8, 12, 23, 32, 99}, 注意合并前的元素都位于同一个有序序列的相邻位置，合并后的有序序列的下标与合并前的序列总的起始下标相同。

算法过程中需要三个整型变量，i 用来遍历归并的前一个有序序列，其初始位置是s；j 用来遍历归并的后一个有序序列，其初始值是u+1；q 用来指出归并后得到的有序序列的末尾元素的位置，其初始值是s。当遍历完成其中的一个有序序列之后，只需把另一个未结束有序序列的剩余元素复制到合并后的有序序列的末尾。

看代码：

 

[cpp] view plain copy
 
  1. //将有序的X[s..u]和X[u+1..v]归并为有序的Z[s..v]  
  2. void merge(int X[], int Z[], int s, int u, int v)  
  3. {  
  4.     int i, j, q;  
  5.     i = s;  
  6.     j = u + 1;  
  7.     q = s;  
  8.   
  9.     while( i <= u && j<= v )  
  10.     {  
  11.         if( X[i] <= X[j] )  
  12.             Z[q++] = X[i++];  
  13.         else  
  14.             Z[q++] = X[j++];  
  15.     }  
  16.   
  17.     while( i <= u )   //将X中剩余元素X[i..u]复制到Z  
  18.         Z[q++] = X[i++];  
  19.     while( j <= v )   //将X中剩余元素X[j..v]复制到Z  
  20.         Z[q++] = X[j++];  
  21. }  


2. 一趟归并扫描子算法：将参加排序的序列分成若干个长度为 t 的，且各自按值有序的子序列，然后多次调用归并子算法merge将所有两两相邻成对的子序列合并成若干个长度为

 

2t 的，且各自按值有序的子序列。

若某一趟归并扫描到最后，剩下的元素个数不足两个子序列的长度时：

 

  • 若剩下的元素个数大于一个子序列的长度 t 时，则再调用一次归并子算法 merge 将剩下的两个不等长的子序列合并成一个有序子序列
  • 若剩下的元素个数小于或者等于一个子序列的长度 t 时，只须将剩下的元素依次复制到前一个子序列后面。
看代码：
[cpp] view plain copy
 
  1. /* X[0..n-1]表示参加排序的初始序列 
  2.  * t为某一趟归并时子序列的长度 
  3.  * 整型变量i指出当前归并的两个子序列中第1个子序列的第1个元素的位置 
  4.  * Y[0..n-1]表示这一趟归并后的结果 
  5. */  
  6. void mergePass(int X[], int Y[], int n, int t)  
  7. {  
  8.     int i = 0, j;  
  9.     while( n - i >= 2 * t )     //将相邻的两个长度为t的各自有序的子序列合并成一个长度为2t的子序列  
  10.     {  
  11.         merge(X, Y, i, i + t - 1, i + 2 * t - 1);  
  12.         i = i + 2 * t;  
  13.     }  
  14.   
  15.     if( n - i > t )       //若最后剩下的元素个数大于一个子序列的长度t时  
  16.         merge(X, Y, i, i + t - 1, n - 1);  
  17.     else             //n-i <= t时，相当于只是把X[i..n-1]序列中的数据赋值给Y[i..n-1]  
  18.         for( j = i ; j < n ; ++j )  
  19.             Y[j] = X[j];  
  20. }  

3. 二路归并排序算法：将参加排序的初始序列分成长度为1的子序列使用mergePass函数进行第一趟排序，得到 n / 2 个长度为 2 的各自有序的子序列（若n为奇数，还会存在一个最后元素的子序列），再一次调用mergePass函数进行第二趟排序，得到 n / 4 个长度为 4 的各自有序的子序列， 第 i 趟排序就是两两归并长度为 2^(i-1) 的子序列得到 n / (2^i) 长度为 2^i 的子序列，直到最后只剩一个长度为n的子序列。由此看出，一共需要 log2n 趟排序，每一趟排序的时间复杂度是 O(n), 由此可知
该算法的总的时间复杂度是是 O(n log2n)，但是该算法需要 O(n) 的辅助空间，空间复杂度很大，是 O(n).
看代码：
[cpp] view plain copy
 
  1. void mergeSort(int X[], int n)  
  2. {  
  3.     int t = 1;  
  4.     int *Y = (int *)malloc(sizeof(int) * n);  
  5.     while( t < n )  
  6.     {  
  7.         mergePass(X, Y, n, t);  
  8.         t *= 2;  
  9.         mergePass(Y, X, n, t);  
  10.         t *= 2;  
  11.     }  
  12.     free(Y);  
  13. }  

程序总的代码汇总：
[cpp] view plain copy
 
  1. #include <stdlib.h>  
  2. #include <stdio.h>  
  3.   
  4. //将有序的X[s..u]和X[u+1..v]归并为有序的Z[s..v]  
  5. void merge(int X[], int Z[], int s, int u, int v)  
  6. {  
  7.     int i, j, q;  
  8.     i = s;  
  9.     j = u + 1;  
  10.     q = s;  
  11.   
  12.     while( i <= u && j<= v )  
  13.     {  
  14.         if( X[i] <= X[j] )  
  15.             Z[q++] = X[i++];  
  16.         else  
  17.             Z[q++] = X[j++];  
  18.     }  
  19.   
  20.     while( i <= u )   //将X中剩余元素X[i..u]复制到Z  
  21.         Z[q++] = X[i++];  
  22.     while( j <= v )   //将X中剩余元素X[j..v]复制到Z  
  23.         Z[q++] = X[j++];  
  24. }  
  25.   
  26. /* X[0..n-1]表示参加排序的初始序列 
  27.  * t为某一趟归并时子序列的长度 
  28.  * 整型变量i指出当前归并的两个子序列中第1个子序列的第1个元素的位置 
  29.  * Y[0..n-1]表示这一趟归并后的结果 
  30. */  
  31. void mergePass(int X[], int Y[], int n, int t)  
  32. {  
  33.     int i = 0, j;  
  34.     while( n - i >= 2 * t )     //将相邻的两个长度为t的各自有序的子序列合并成一个长度为2t的子序列  
  35.     {  
  36.         merge(X, Y, i, i + t - 1, i + 2 * t - 1);  
  37.         i = i + 2 * t;  
  38.     }  
  39.   
  40.     if( n - i > t )       //若最后剩下的元素个数大于一个子序列的长度t时  
  41.         merge(X, Y, i, i + t - 1, n - 1);  
  42.     else             //n-i <= t时，相当于只是把X[i..n-1]序列中的数据赋值给Y[i..n-1]  
  43.         for( j = i ; j < n ; ++j )  
  44.             Y[j] = X[j];  
  45. }  
  46.   
  47. void mergeSort(int X[], int n)  
  48. {  
  49.     int t = 1;  
  50.     int *Y = (int *)malloc(sizeof(int) * n);  
  51.     while( t < n )  
  52.     {  
  53.         mergePass(X, Y, n, t);  
  54.         t *= 2;  
  55.         mergePass(Y, X, n, t);  
  56.         t *= 2;  
  57.     }  
  58.     free(Y);  
  59. }  
  60.   
  61. void print_array(int array[], int n)  
  62. {  
  63.     int i;  
  64.     for( i = 0 ; i < n ; ++i )  
  65.         printf("%d ", array[i]);  
  66.     printf("\n");  
  67. }  
  68.   
  69. int main()  
  70. {  
  71.     int array[] = {65, 2, 6, 1, 90, 78, 105, 67, 35, 23, 3, 88, -22};  
  72.     int size = sizeof(array) / sizeof(int);  
  73.     mergeSort(array, size);  
  74.     print_array(array, size);  
  75.     return 0;  
  76. }  


归并排序自顶向下排序，仅供参考：
[cpp] view plain copy
 
  1. void merge2(int *data, int start, int mid, int end)  
  2. {  
  3.     int *temp = (int *)malloc((end-start+1)*sizeof(int));  
  4.     int i = start;  
  5.     int j = mid + 1;  
  6.     int k = 0;  
  7.     while(i <= mid && j <= end)  
  8.     {  
  9.         temp[k++] = data[i] <= data[j] ? data[i++] : data[j++];  
  10.     }  
  11.   
  12.     while(i <= mid)  
  13.         temp[k++] = data[i++];  
  14.     while(j <= end)  
  15.         temp[k++] = data[j++];  
  16.   
  17.     k = 0;  
  18.     for(i = start; i <= end; ++i)  
  19.         data[i] = temp[k++];  
  20.   
  21.     free(temp);  
  22. }  
  23. //从顶往下  
  24. void mergeSort2(int *data, int start, int end, int *des)  
  25. {  
  26.     if(start == end)  
  27.         return;  
  28.   
  29.     int mid = (end + start)/2;  
  30.     mergeSort2(data, start, mid, des);  
  31.     mergeSort2(data, mid+1, end, des);  
  32.     merge2(data, start, mid, end);  
  33. }  
    1. 转自：http://blog.csdn.net/caryaliu/article/details/7475700
posted @ 2017-11-16 19:22  瘋耔  阅读(1792)  评论(0)  编辑  收藏  举报
跳至侧栏