（转）排序算法——归并排序与递归

基本思想

分析归并排序之前，我们先来了解一下分治算法。

分治算法的基本思想是将一个规模为N的问题分解为K个规模较小的子问题，这些子问题相互独立且与原问题性质相同。求出子问题的解，就可得到原问题的解。

分治算法的一般步骤：

（1）分解，将要解决的问题划分成若干规模较小的同类问题；

（2）求解，当子问题划分得足够小时，用较简单的方法解决；

（3）合并，按原问题的要求，将子问题的解逐层合并构成原问题的解。

归并排序是分治算法的典型应用。

归并排序先将一个无序的N长数组切成N个有序子序列（只有一个数据的序列认为是有序序列），然后两两合并，再将合并后的N/2（或者N/2 + 1）个子序列继续进行两两合并，以此类推得到一个完整的有序数组。过程如下图所示：

java实现

归并排序的核心思想是将两个有序的数组归并到另一个数组中，所以需要开辟额外的空间。

第一步要理清归并的思路。假设现在有两个有序数组A和B，要将两者有序地归并到数组C中。我们用一个实例来推演：

上图中，A数组中有四个元素，B数组中有六个元素，首先比较A、B中的第一个元素，将较小的那个放到C数组的第一位，因为该元素就是A、B所有元素中最小的。上例中，7小于23，所以将7放到了C中。

然后，用23与B中的其他元素比较，如果小于23，继续按顺序放到C中；如果大于23，则将23放入C中。

23放入C中之后，用23之后的47作为基准元素，与B中的其他元素继续比较，重复上面的步骤。

如果有一个数组的元素已经全部复制到C中了，那么将另一个数组中的剩余元素依次插入C中即可。至此结束。

按照上面的思路，用java实现：

[java] view plaincopyprint?

  1. /**
  2. * 归并arrayA与arrayB到arrayC中
  3. * @param arrayA  待归并的数组A
  4. * @param sizeA 数组A的长度
  5. * @param arrayB  待归并的数组B
  6. * @param sizeB 数组B的长度
  7. * @param arrayC  辅助归并排序的数组
  8. */
  9. public static void merge(int [] arrayA,int sizeA,
  10. int [] arrayB,int sizeB,
  11. int [] arrayC){
  12. int i=0,j=0,k=0;  //分别当作arrayA、arrayB、arrayC的下标指针
  13. while(i<sizeA&& j<sizeB){  //两个数组都不为空
  14. if(arrayA[i]<arrayB[j]){//将两者较小的那个放到arrayC中
  15. arrayC[k++]= arrayA[i++];
  16. }else{
  17. arrayC[k++]= arrayB[j++];
  18. }
  19. }  //该循环结束后，一个数组已经完全复制到arrayC中了，另一个数组中还有元素
  20. //后面的两个while循环用于处理另一个不为空的数组
  21. while(i<sizeA){
  22. arrayC[k++]= arrayA[i++];
  23. }
  24. while(j<sizeB){
  25. arrayC[k++]= arrayA[j++];
  26. }
  27. for(intl=0;l<arrayC.length;l++){  //打印新数组中的元素
  28. System.out.print(arrayC[l]+"\t");
  29. }
  30. }

再归并之前，还有一步工作需要提前做好，就是数组的分解，可以通过递归的方法来实现。递归（Recursive）是算法设计中常用的思想。

这样通过先递归的分解数组，再合并数组就完成了归并排序。

完整的java代码如下：

[java] view plaincopyprint?

  1. public class Sort {
  2. private int [] array;  //待排序的数组
  3. public Sort(int [] array){
  4. this.array= array;
  5. }
  6. //按顺序打印数组中的元素
  7. public void display(){
  8. for(int i=0;i<array.length;i++){
  9. System.out.print(array[i]+"\t");
  10. }
  11. System.out.println();
  12. }
  13. //归并排序
  14. public void mergeSort(){
  15. int[] workSpace = new int [array.length]; //用于辅助排序的数组
  16. recursiveMergeSort(workSpace,0,workSpace.length-1);
  17. }
  18. /**
  19. * 递归的归并排序
  20. * @param workSpace  辅助排序的数组
  21. * @param lowerBound 欲归并数组段的最小下标
  22. * @param upperBound 欲归并数组段的最大下标
  23. */
  24. private void recursiveMergeSort(int [] workSpace,int lowerBound,int upperBound){
  25. if(lowerBound== upperBound){  //该段只有一个元素，不用排序
  26. return;
  27. }else{
  28. int mid = (lowerBound+upperBound)/2;
  29. recursiveMergeSort(workSpace,lowerBound,mid);    //对低位段归并排序
  30. recursiveMergeSort(workSpace,mid+1,upperBound);  //对高位段归并排序
  31. merge(workSpace,lowerBound,mid,upperBound);
  32. display();
  33. }
  34. }
  35. /**
  36. * 对数组array中的两段进行合并，lowerBound~mid为低位段，mid+1~upperBound为高位段
  37. * @param workSpace 辅助归并的数组，容纳归并后的元素
  38. * @param lowerBound 合并段的起始下标
  39. * @param mid 合并段的中点下标
  40. * @param upperBound 合并段的结束下标
  41. */
  42. private void merge(int [] workSpace,int lowerBound,int mid,int upperBound){
  43. int lowBegin = lowerBound;  //低位段的起始下标
  44. int lowEnd = mid;           //低位段的结束下标
  45. int highBegin = mid+1;  //高位段的起始下标
  46. int highEnd = upperBound;  //高位段的结束下标
  47. int j = 0; //workSpace的下标指针
  48. int n = upperBound-lowerBound+1;  //归并的元素总数
  49. while(lowBegin<=lowEnd && highBegin<=highEnd){
  50. if(array[lowBegin]<array[highBegin]){//将两者较小的那个放到workSpace中
  51. workSpace[j++]= array[lowBegin++];
  52. }else{
  53. workSpace[j++]= array[highBegin++];
  54. }
  55. }
  56. while(lowBegin<=lowEnd){
  57. workSpace[j++]= array[lowBegin++];
  58. }
  59. while(highBegin<=highEnd){
  60. workSpace[j++]= array[highBegin++];
  61. }
  62. for(j=0;j<n;j++){  //将归并好的元素复制到array中
  63. array[lowerBound++]= workSpace[j];
  64. }
  65. }
  66. }

用以下代码测试：

[java] view plaincopyprint?

  1. int [] a ={6,2,7,4,8,1,5,3};
  2. Sort sort = newSort(a);
  3. sort.mergeSort();

打印结果如下：

归并的顺序是这样的：先将初始数组分为两部分，先归并低位段，再归并高位段。对低位段与高位段继续分解，低位段分解为更细分的一对低位段与高位段，高位段同样分解为更细分的一对低位段与高位段，依次类推。

上例中，第一步，归并的是6与2，第二步归并的是7和4，第三部归并的是前两步归并好的子段[2,6]与[4,7]。至此，数组的左半部分（低位段）归并完毕，然后归并右半部分（高位段）。

所以第四步归并的是8与1，第四部归并的是5与3，第五步归并的是前两步归并好的字段[1,8]与[3,5]。至此，数组的右半部分归并完毕。

最后一步就是归并数组的左半部分[2,4,6,7]与右半部分[1,3,5,8]。

归并排序结束。

在本文开始对归并排序的描述中，第一躺归并是对所有相邻的两个元素归并结束之后，才进行下一轮归并，并不是先归并左半部分，再归并右半部分，但是程序的执行顺序与我们对归并排序的分析逻辑不一致，所以理解起来有些困难。

下面结合代码与图例来详细分析一下归并排序的过程。

虚拟机栈（VM  Stack）是描述Java方法执行的内存模型，每一次方法的调用都伴随着一次压栈、出栈操作。

我们要排序的数组为：

int [] a = {6,2,7,4,8,1,5,3}

当main()方法调用mergeSort()方法时，被调用的方法被压入栈中，然后程序进入mergeSort()方法：

[java] view plaincopyprint?

  1. public void mergeSort(){
  2. int[] workSpace = new int [array.length]; //用于辅助排序的数组
  3. recursiveMergeSort(workSpace,0,workSpace.length-1);
  4. }

此时，mergeSort()又调用了recursiveMergeSort(workSpace,0,7)方法，recursiveMergeSort(workSpace,0,7)方法也被压入栈中，在mergeSort()之上。

然后，程序进入到recursiveMergeSort(workSpace,0,7)方法：

[java] view plaincopyprint?

  1. if(lowerBound== upperBound){  //该段只有一个元素，不用排序
  2. return;
  3. }else{
  4. int mid = (lowerBound+upperBound)/2;
  5. recursiveMergeSort(workSpace,lowerBound,mid);    //对低位段归并排序
  6. recursiveMergeSort(workSpace,mid+1,upperBound);  //对高位段归并排序
  7. merge(workSpace,lowerBound,mid,upperBound);
  8. display();
  9. }

lowerBound参数值为0，upperBound参数值为7，不满足lowerBound== upperBound的条件，所以方法进入else分支，然后调用方法recursiveMergeSort(workSpace,0,3) ，

recursiveMergeSort(workSpace,0,3)被压入栈中,此时栈的状态如下：

然而，recursiveMergeSort(workSpace,0,3)不能立即返回，它在内部又会调用recursiveMergeSort(workSpace,0,1)，recursiveMergeSort(workSpace,0,1)又调用了recursiveMergeSort(workSpace,0,0)，此时，栈中的状态如下：

程序运行到这里，终于有一个方法可以返回了结果了——recursiveMergeSort(workSpace,0,0)，该方法的执行的逻辑是对数组中的下标从0到0的元素进行归并，该段只有一个元素，所以不用归并，立即return。

方法一旦return，就意味着方法结束，recursiveMergeSort(workSpace,0,0)从栈中弹出。这时候，程序跳到了代码片段（二）中的第二行：

recursiveMergeSort(workSpace,1,1);

该方法入栈，与recursiveMergeSort(workSpace,0,0)类似，不用归并，直接返回，方法出栈。

这时候程度跳到了代码片段（二）中的第三行：

merge(workSpace,0,0,1);

即对数组中的前两个元素进行合并（自然，merge(workSpace,0,0,1)也伴随着一次入栈与出栈）。

至此，代码片段（二）执行完毕，recursiveMergeSort(workSpace,0,1)方法出栈，程序跳到代码片段（三）的第二行：

recursiveMergeSort(workSpace,2,3);

该方法是对数组中的第三个、第四个元素进行归并，与执行recursiveMergeSort(workSpace,0,1)的过程类似，最终会将第三个、第四个元素归并排序。

然后，程序跳到程序跳到代码片段（三）的第三行：

merge(workSpace,0,1,3);

将前面已经排好序的两个子序列（第一第二个元素为一组、第三第四个元素为一组）合并。

然后recursiveMergeSort(workSpace,0,3)出栈，程序跳到代码片段（四）的第二行：

recursiveMergeSort(workSpace,4,7);

对数组的右半部分的四个元素进行归并排序，伴随着一系列的入栈、出栈，最后将后四个元素排好。此时，数组的左半部分与右半部分已经有序。

然后程序跳到代码片段（四）第三行：

merge(workSpace,0,3,7);

对数组的左半部分与右半部分合并。

然后recursiveMergeSort(workSpace,4,7)出栈，mergeSort()出栈，最后main()方法出栈，程序结束。

算法分析

先来分析一下复制的次数。

如果待排数组有8个元素，归并排序需要分3层，第一层有四个包含两个数据项的自数组，第二层包含两个包含四个数据项的子数组，第三层包含一个8个数据项的子数组。合并子数组的时候，每一层的所有元素都要经历一次复制（从原数组复制到workSpace数组），复制总次数为3*8=24次，即层数乘以元素总数。

设元素总数为N，则层数为log2N，复制总次数为N*log2N。

其实，除了从原数组复制到workSpace数组，还需要从workSpace数组复制到原数组，所以，最终的复制复制次数为2*N*log2N。

在大O表示法中，常数可以忽略，所以归并排序的时间复杂度为O(N* log2N)。

一般来讲，复制操作的时间消耗要远大于比较操作的时间消耗，时间复杂度是由复制次数主导的。

下面我们再来分析一下比较次数。

在归并排序中，比较次数总是比复制次数少一些。现在给定两个各有四个元素的子数组，首先来看一下最坏情况和最好情况下的比较次数为多少。

第一种情况，数据项大小交错，所以必须进行7次比较，第二种情况中，一个数组比另一个数组中的所有元素都要小，因此只需要4次比较。

当归并两个子数组时，如果元素总数为N，则最好情况下的比较次数为N/2，最坏情况下的比较次数为N-1。

假设待排数组的元素总数为N，则第一层需要N/2次归并，每次归并的元素总数为2；则第一层需要N/4次归并，每次归并的元素总数为4；则第一层需要N/8次归并，每次归并的元素总数为8……最后一次归并次数为1，归并的元素总数为N。总层数为log2N。

最好情况下的比较总数为：

N/2*(2/2)+ N/4*(4/2)+N/8*(8/2)+...+1*(N/2) = (N/2)*log2N

最好情况下的比较总数为：

N/2*(2-1)+ N/4*(4-1)+N/8*(8-1)+...+1*(N-1) =

(N-N/2)+ (N-N/4)+(N-N/8)+...+(N-1)=

N*log2N-(1+N/2+N/4+..)< N*log2N

可见，比较次数介于(N/2)*log2N与N*log2N之间。如果用大O表示法，时间复杂度也为O(N* log2N)。

转至http://blog.csdn.net/u012152619/article/details/47345107。

时间： 2024-08-09 16:01:26

（转）排序算法——归并排序与递归的相关文章

排序算法——归并排序

归并排序是分治法的典型举例. 分治法的思想是,将原有问题分解为几个规模较小但类似于原问题的子问题,递归的求解这些子问题,然后再合并这些子问题的解来建立原问题的解. 分治模式在每层递归时都有三个步骤: 分解原问题为若干子问题,这些子问题是原问题的规模较小的实例. 解决这些子问题,递归地求解各子问题.然而,若子问题的规模足够小,则直接求解. 合并这些子问题的解成原问题的解. 归并排序算法完全遵循分治模式.直观上其操作如下: 分解:分解待排序的n个元素的序列成各具n/2个元素的两个子序列. 解决:使用

经典排序算法 - 归并排序Merge sort

经典排序算法 - 归并排序Merge sort 原理,把原始数组分成若干子数组,对每个子数组进行排序, 继续把子数组与子数组合并,合并后仍然有序,直到所有合并完,形成有序的数组 举例 无序数组[6 2 4 1 5 9] 先看一下每一个步骤下的状态,完了再看合并细节 第一步 [6 2 4 1 5 9]原始状态 第二步 [2 6] [1 4] [5 9]两两合并排序,排序细节后边介绍 第三步 [1 2 4 6] [5 9]继续两组两组合并 第四步 [1 2 4 5 6 9]合并完成,排序完成 输出结

4.比较排序之归并排序（递归）

归并排序里运用到算法里很重要的一个思想——分治法:将原问题分解为几个规模较小但类似于原问题的子问题——<算法导论>.在每一层递归中都有3个步骤: 1.分解问题 2.解决问题 3.合并问题的解 举例待排序数组:{6, 5, 3, 1, 7, 2, 4},将它原始序列做分解. 可以经过不断的递归分解可以看到已经把原始数组序列不断分解为最小单位,接下来不妨将它们看做是二叉树的叶子节点. 将他们进行两两归并排序形成二叉树(也称为2路归并算法),可见二叉树的根节点即为最终序列.在这个过程中我们完成了剩余

三种排序算法(归并排序、快速排序，堆排序)

归并排序:建立在归并操作上的一种有效的排序算法,该算法是采用分治法(Divide and Conquer)的一个非常典型的应用.将已有序的子序列合并,得到完全有序的序列:即先使每个子序列有序,再使子序列段间有序.若将两个有序表合并成一个有序表,称为二路归并. 归并排序算法稳定,数组需要O(n)的额外空间,链表需要O(log(n))的额外空间,时间复杂度为O(nlog(n)),算法不是自适应的,不需要对数据的随机读取. 工作原理: 1.申请空间,使其大小为两个已经排序序列之和,该空间用来存放合并后

经典排序算法---归并排序

归并排序(MERGE-SORT)是建立在归并操作上的一种有效的排序算法,该算法是采用分治法(Divide and Conquer)的一个非常典型的应用.将已有序的子序列合并,得到完全有序的序列:即先使每个子序列有序,再使子序列段间有序.若将两个有序表合并成一个有序表,称为二路归并 代码: void mergearray(struct SQ_LIST *v, int first, int mid, int last, int temp[]) { int i = first, j = mid + 1

js 实现排序算法 -- 归并排序（Merge Sort）

原文: 十大经典排序算法(动图演示) 归并排序 归并排序是建立在归并操作上的一种有效的排序算法.该算法是采用分治法(Divide and Conquer)的一个非常典型的应用.将已有序的子序列合并,得到完全有序的序列:即先使每个子序列有序,再使子序列段间有序.若将两个有序表合并成一个有序表,称为2-路归并. 算法描述 把长度为n的输入序列分成两个长度为n/2的子序列: 对这两个子序列分别采用归并排序: 将两个排序好的子序列合并成一个最终的排序序列. 动图演示 代码实现 function merg

排序算法-归并排序（Java）

package com.rao.sort; import java.util.Arrays; /** * @author Srao * @className MergeSort * @date 2019/12/7 10:24 * @package com.rao.sort * @Description 归并排序 */public class MergeSort { /** * 归并排序:递归写法 * @param arr:要排序的数组 * @param left:数组最左边的元素的下标 * @p

排序算法--归并排序（merge）

归并排序是利用递归和分而治之的技术将数据序列划分成为越来越小的半子表,再对半子表排序,最后再用递归步骤将排好序的半子表合并成为越来越大的有序序列,归并排序包括两个步骤,分别为: 1)划分子表  2)合并半子表 时间复杂度是Θ(nlgn),优于插入排序算法. 算法描述    1) 申请空间,使其大小为两个已经排序序列之和,该空间用来存放合并后的序列    2) 设定两个指针,最初位置分别为两个已经排序序列的起始位置    3) 比较两个指针所指向的元素,选择相对小的元素放入到合并空间,并移动指针到

数据结构和算法-排序算法-归并排序

##################     归并排序        ####################### """ 归并算法逻辑 拆分 对整个序列进行拆分,左边一部分,右边一部分 然后对每一部分再次进行拆分,一直到拆分到只有一个元素,就到头了, 第1次拆分:54, 26, 93, 17, 77, 31, 44, 55, 第2次拆分:54, 26, 93, 17, 77, 31, 44, 55, 第3次拆分:54, 26, 93, 17, 77, 31, 44, 55