devbox
很楠不爱3
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

基本排序之详解归并排序_归并排序归并次数

作者：很楠不爱3 | 2024-05-03 19:46:41

赞

踩

归并排序归并次数

                                 

                                                                       归并排序


一、归并排序的效率是仅次于快速排序的稳定的排序算法，其时间复杂度为O(nlog2n)。我们对n 个元素进行一次归并排序时，归并的次数约为log2n，每一次的两路归并排序元素的比较次数约为n-1。


二、归并排序的基本思想：

        归并排序是通过将一列数组序列中的元素看成一个一个的小序列来进行归并，直到所有的元素都被归并完成后，排序即完成，便是成功的完成了排序操作。


三、原理：

        如：我们对n 为9吧，这样更加好，如，a[9] = {1,2,5,4,3,8,6,7,9}这样的一个数组：

         原数组：

                      1       2      5     4      3      8     6    7     9

         第一次归并：

                     [1    2]    [4    5]    [3    8]    [6     7]     [9]

         第二次归并：

                     [1    2      4     5]      [3    6     7     8]     [9]

         第三次归并：

                   [1    2     3       4      5     6      7    8]     [9]   

         第四次归并：

                    [1    2     3       4      5     6      7    8      9]  

实现归并的操作代码：

  1. 			     for(i = L1,j = L2;i<=u1&&j <= u2;){ 
  2. 			         if(a[i] <= a[j]){
  3. 					        A->swap[pos] = a[i];
  4. 							i++;
  5. 						    pos++;
  6. 					   }else{
  7. 						    A->swap[pos] =  a[j];
  8. 						    j++;
  9. 						    pos++;				   
  10. 					   }
  11. 			     }
  12. 				
  13. 			   //此时我们要做的已经归并完成了
  14. 			   //此时我们要对在数组序列没有归并的进行归并
  15. 			   while(i <= u1 ){
  16. 			         A->swap[pos]=a[i];
  17. 					 i++;
  18. 					 pos++;
  19. 			   }
  20. 			   while(j <= u2 ){
  21. 			          A->swap[pos] = a[j];
  22. 					  j++;
  23. 					  pos++;
  24. 			   }
  25. 			   //此时对两个数组序列已经彻底归并完成了，而且此时是有序序列
  26. 			   //此时的L1 = u2+1了
  27. 			   L1 = u2 +1;
  28. 		//这里我们把只有一组的也存放到swap中
  29. 		for(int i = L1;i<length1;i++){
  30. 		       A->swap[i] = a[i];
  31. 		}


实现一次执行归并的核心代码：

  1. /**
  2. *归并排序的一次执行
  3. *@param   int a[] 为接收的数组
  4. *@param   int lenghth1 为此接收数组的长度
  5. *@param   int swap[], 为保存执行完毕一次归并排序后的数组
  6. *@param   int length2 为此归并好了的数组序列的长度
  7. *@return  无
  8. */
  9. void Merge(int a[],int length1 ,Array *A,int length2){
  10. 	    
  11. 	   //接收了数组我们需要对其进行归并和一次排序这时我们定义两个有指向的“指针”
  12. 	    int u1,u2;//此为这两个便于扫描的指针
  13. 	   //此时又需要定义两个数组序列的下界
  14. 		int L1,L2;
  15. 		//我们可以知道第一个数组序列的下界为0
  16. 		L1 = 0;
  17. 		//此时设置swap中的下标值pos来保存归并成功的数,因为pos是针对这整个循环的所以只能放在循环外面
  18. 	    int pos = 0;
  19. 		while(L1+length2<length1){
  20. 		       //我们可以得到第二个数组序列的下界了
  21. 		       L2 = L1 +length2;
  22. 	           //此时让u1,u2指向数组序列的上界
  23. 		       u1 =L2 -1;
  24. 	          //这时我们需要判断第二个数组序列是否越界，因为这时会出现最后一个数组序列不满length2这个值如[1 2 3  4][6]
  25. 		       if(L2 +length2-1< length1-1){
  26. 		               u2 = L2 +length2-1;
  27. 		       }else{
  28. 		               u2 = length1-1;
  29. 		       }
  30. 		     //现在我们把所有的指向问题都解决了，现在就需要进行扫描归并操作了
  31. 		     //此时对两个数组序列进行归并排序
  32. 		       int i,j;
  33. 			   i = L1,j = L2;
  34. 			   /**
  35. 			     *这里是方便的操作
  36. 			     *for(i = L1,j = L2;i<=u1&&j <= u2;){ 
  37. 			     *   if(a[i] <= a[j]){
  38. 				 *	        A->swap[pos] = a[i];
  39. 				 *			i++;
  40. 				 *		    pos++;
  41. 				 *	   }else{
  42. 				 *		    A->swap[pos] =  a[j];
  43. 				 *		    j++;
  44. 				 *		    pos++;				   
  45. 				 *	   }
  46. 				 * }
  47. 				 */
  48. 			   for(;;){
  49. 				   if(i<=u1&&j <= u2){
  50. 					   if(a[i] <= a[j]){
  51. 					        A->swap[pos] = a[i];
  52. 							i++;
  53. 							pos++;
  54. 					   }else{
  55. 						    A->swap[pos] =  a[j];
  56. 						    j++;
  57. 						    pos++;				   
  58. 					   }
  59. 				   }else{
  60. 				        break;
  61. 				   }
  62. 			   }
  63. 			   //此时我们要做的已经归并完成了
  64. 			   //此时我们要对在数组序列没有归并的进行归并
  65. 			   while(i <= u1 ){
  66. 			         A->swap[pos]=a[i];
  67. 					 i++;
  68. 					 pos++;
  69. 			   }
  70. 			   while(j <= u2 ){
  71. 			          A->swap[pos] = a[j];
  72. 					  j++;
  73. 					  pos++;
  74. 			   }
  75. 			   //此时对两个数组序列已经彻底归并完成了，而且此时是有序序列
  76. 			   //此时的L1 = u2+1了
  77. 			   L1 = u2 +1;
  78. 	    }
  79.  
  80. 		//cout<<"L1"<<L1<<endl;
  81. 		//cout<<"lenght1"<<length1<<endl;
  82. 	    /*for(int i = 0;i <length1 ;i++){
  83. 		      cout<<"A->swap[i]......i="<<i<<"  "<<A->swap[i]<<endl;
  84. 		}*/
  85. 		//这里我们把只有一组的也存放到swap中
  86. 		for(int i = L1;i<length1;i++){
  87. 		       A->swap[i] = a[i];
  88. 		}
  89. 		//这样一次归并操作彻底完成了
  90. 		/*for(int i = 0;i <length1 ;i++){
  91. 		      cout<<"A->swap[i]......i="<<i<<"  "<<A->swap[i]<<endl;
  92. 		}
  93. 		cout<<"count....."<<count<<endl;*/
  94. }
实现归并排序的代码段： 

  1. /**
  2. *归并排序
  3. *@param int a[]带归并的数组序列
  4. *@param int length1 为带归并的数组序列的长度
  5. *@return 无
  6. */
  7. void Merge_sort(int a[],int length1){
  8. 	  //我们知道我们以数组长度为1开始归并
  9. 	  int length2 = 1;
  10. 	  //这里我们需要申请一个swap空间来作为交换的空间
  11. 	  Array *A =NULL;
  12. 	  if(A != NULL){
  13. 		  free(A);
  14. 	  }
  15. 	  A = (Array *)malloc(sizeof(Array )*length1);
  16. 	  if(A != NULL){
  17. 	       cout<<"申请空间成功！"<<endl;
  18. 	  }
  19. 	  while(length2 <length1){//直到归并完成Across跳出循环
  20. 	       Merge(a,length1,A,length2); 
  21. 		   for(int i = 0;i <length1;i++){
  22. 		         a[i]  = A->swap[i];//这里把归并后的数组序列再次保存回a[i]中
  23. 		   }
  24. 		   //这里需要更改归并后的新数组序列的长度
  25. 		   length2 = 2*length2;
  26. 	  }
  27. 	  //记住最后一定要对空间进行释放
  28. 	  free(A);
  29. }
全部代码： 

  1. /**
  2. *归并排序就是将一个数组分成若干个数组然后两两合并直到合并完成最后一个数组
  3. *@author 菜鸟
  4. *@version 2014.6.15
  5. */
  6. #include <iostream>
  7. #include <malloc.h>
  8. #include <windows.h>
  9. #define maxSize  100
  10. using namespace std;
  11. typedef int DataType;
  12. typedef struct{
  13.      DataType swap[maxSize];
  14. }Array;
  15. /**
  16. *归并排序的一次执行
  17. *@param   int a[] 为接收的数组
  18. *@param   int lenghth1 为此接收数组的长度
  19. *@param   int swap[], 为保存执行完毕一次归并排序后的数组
  20. *@param   int length2 为此归并好了的数组序列的长度
  21. *@return  无
  22. */
  23. void Merge(int a[],int length1 ,Array *A,int length2){
  24. 	    
  25. 	   //接收了数组我们需要对其进行归并和一次排序这时我们定义两个有指向的“指针”
  26. 	    int u1,u2;//此为这两个便于扫描的指针
  27. 	   //此时又需要定义两个数组序列的下界
  28. 		int L1,L2;
  29. 		//我们可以知道第一个数组序列的下界为0
  30. 		L1 = 0;
  31. 		//此时设置swap中的下标值pos来保存归并成功的数,因为pos是针对这整个循环的所以只能放在循环外面
  32. 	    int pos = 0;
  33. 		while(L1+length2<length1){
  34. 		       //我们可以得到第二个数组序列的下界了
  35. 		       L2 = L1 +length2;
  36. 	           //此时让u1,u2指向数组序列的上界
  37. 		       u1 =L2 -1;
  38. 	          //这时我们需要判断第二个数组序列是否越界，因为这时会出现最后一个数组序列不满length2这个值如[1 2 3  4][6]
  39. 		       if(L2 +length2-1< length1-1){
  40. 		               u2 = L2 +length2-1;
  41. 		       }else{
  42. 		               u2 = length1-1;
  43. 		       }
  44. 		     //现在我们把所有的指向问题都解决了，现在就需要进行扫描归并操作了
  45. 		     //此时对两个数组序列进行归并排序
  46. 		       int i,j;
  47. 			   i = L1,j = L2;
  48. 			   /**
  49. 			     *这里是方便的操作
  50. 			     *for(i = L1,j = L2;i<=u1&&j <= u2;){ 
  51. 			     *   if(a[i] <= a[j]){
  52. 				 *	        A->swap[pos] = a[i];
  53. 				 *			i++;
  54. 				 *		    pos++;
  55. 				 *	   }else{
  56. 				 *		    A->swap[pos] =  a[j];
  57. 				 *		    j++;
  58. 				 *		    pos++;				   
  59. 				 *	   }
  60. 				 * }
  61. 				 */
  62. 			   for(;;){
  63. 				   if(i<=u1&&j <= u2){
  64. 					   if(a[i] <= a[j]){
  65. 					        A->swap[pos] = a[i];
  66. 							i++;
  67. 							pos++;
  68. 					   }else{
  69. 						    A->swap[pos] =  a[j];
  70. 						    j++;
  71. 						    pos++;				   
  72. 					   }
  73. 				   }else{
  74. 				        break;
  75. 				   }
  76. 			   }
  77. 			   //此时我们要做的已经归并完成了
  78. 			   //此时我们要对在数组序列没有归并的进行归并
  79. 			   while(i <= u1 ){
  80. 			         A->swap[pos]=a[i];
  81. 					 i++;
  82. 					 pos++;
  83. 			   }
  84. 			   while(j <= u2 ){
  85. 			          A->swap[pos] = a[j];
  86. 					  j++;
  87. 					  pos++;
  88. 			   }
  89. 			   //此时对两个数组序列已经彻底归并完成了，而且此时是有序序列
  90. 			   //此时的L1 = u2+1了
  91. 			   L1 = u2 +1;
  92. 	    }
  93.  
  94.  
  95. 		//cout<<"L1"<<L1<<endl;
  96. 		//cout<<"lenght1"<<length1<<endl;
  97. 	    /*for(int i = 0;i <length1 ;i++){
  98. 		      cout<<"A->swap[i]......i="<<i<<"  "<<A->swap[i]<<endl;
  99. 		}*/
  100. 		//这里我们把只有一组的也存放到swap中
  101. 		for(int i = L1;i<length1;i++){
  102. 		       A->swap[i] = a[i];
  103. 		}
  104. 		//这样一次归并操作彻底完成了
  105. 		/*for(int i = 0;i <length1 ;i++){
  106. 		      cout<<"A->swap[i]......i="<<i<<"  "<<A->swap[i]<<endl;
  107. 		}
  108. 		cout<<"count....."<<count<<endl;*/
  109. }
  110. /**
  111. *归并排序
  112. *@param int a[]带归并的数组序列
  113. *@param int length1 为带归并的数组序列的长度
  114. *@return 无
  115. */
  116. void Merge_sort(int a[],int length1){
  117. 	  //我们知道我们以数组长度为1开始归并
  118. 	  int length2 = 1;
  119. 	  //这里我们需要申请一个swap空间来作为交换的空间
  120. 	  Array *A =NULL;
  121. 	  if(A != NULL){
  122. 		  free(A);
  123. 	  }
  124. 	  A = (Array *)malloc(sizeof(Array )*length1);
  125. 	  if(A != NULL){
  126. 	       cout<<"申请空间成功！"<<endl;
  127. 	  }
  128. 	  while(length2 <length1){//直到归并完成Across跳出循环
  129. 	       Merge(a,length1,A,length2); 
  130. 		   for(int i = 0;i <length1;i++){
  131. 		         a[i]  = A->swap[i];//这里把归并后的数组序列再次保存回a[i]中
  132. 		   }
  133. 		   //这里需要更改归并后的新数组序列的长度
  134. 		   length2 = 2*length2;
  135. 	  }
  136. 	  //记住最后一定要对空间进行释放
  137. 	  free(A);
  138. }
  139. /**
  140. *这里需要一个输出函数，对数组序列进行输出out_put()
  141. *@param int a[] 表示接受此数组的地址
  142. *@param int length 表示此数组的长度
  143. *@return 无
  144. */
  145.  
  146.  
  147. void out_put(int a[],int length){
  148. 	for(int i = 0; i< length ;i++){
  149. 	        cout<<"第"<<i+1<<"个元素："<<a[i]<<endl;
  150. 	}
  151. 	cout<<"输出完成！"<<endl;
  152. }
  153.  
  154.  
  155. int main(){
  156. 	  int a[10] = {1,2,5,4,3,8,6,7,9,0};
  157. 	  cout<<"未经排序的序列："<<endl;
  158. 	  out_put(a,10);
  159. 	  Merge_sort(a,10);
  160. 	  cout<<"经归并排序后的序列："<<endl;
  161. 	  out_put(a,10);
  162.           system("PAUSE");
  163. 	  return 1;
  164.  
  165.  
  166. }


声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/很楠不爱3/article/detail/531239
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号