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

归并排序是稳定的，它的最差，平均，最好时间都是O(nlogn)。但是它需要额外的存储空间，这在某些内存紧张的机器上会受到限制。

    归并算法是又分割和归并两部分组成的。对于分割部分，如果我们使用二分查找的话，时间是O(logn)，在最后归并的时候，时间是O(n)，所以总的时间是O(nlogn)。

归并排序是建立在归并操作上的一种有效的排序算法。该算法是采用分治法（Divide and Conquer）的一个非常典型的应用。

首先考虑下如何将将二个有序数列合并。这个非常简单，只要从比较二个数列的第一个数，谁小就先取谁，取了后就在对应数列中删除这个数。然后再进行比较，如果有数列为空，那直接将另一个数列的数据依次取出即可。

[cpp] view plain copy

1. //将有序数组a[]和b[]合并到c[]中  
2. void MemeryArray(int a[], int n, int b[], int m, int c[])  
3. {  
4.     int i, j, k;  
5.   
6.     i = j = k = 0;  
7.     while (i < n && j < m)  
8.     {  
9.         if (a[i] < b[j])  
10.             c[k++] = a[i++];  
11.         else  
12.             c[k++] = b[j++];   
13.     }  
14.   
15.     while (i < n)  
16.         c[k++] = a[i++];  
17.   
18.     while (j < m)  
19.         c[k++] = b[j++];  
20. }  

可以看出合并有序数列的效率是比较高的，可以达到O(n)。

解决了上面的合并有序数列问题，再来看归并排序，其的基本思路就是将数组分成二组A，B，如果这二组组内的数据都是有序的，那么就可以很方便的将这二组数据进行排序。如何让这二组组内数据有序了？

可以将A，B组各自再分成二组。依次类推，当分出来的小组只有一个数据时，可以认为这个小组组内已经达到了有序，然后再合并相邻的二个小组就可以了。这样通过先递归的分解数列，再合并数列就完成了归并排序。

[cpp] view plain copy
#include <stdio.h>

1. #include <stdlib.h>
   #include <string.h>
   void mergearray(int a[],int first,int mid,int end,int temp[])
   {
       int i,j,k=0,m;
       for(i=first,j=mid+1;i<=mid&&j<=end;)
       {
           if(a[i]>a[j])
               temp[k++]=a[i++];
           else
               temp[k++]=a[j++];
       }
       while(i<=mid)
           temp[k++]=a[i++];
       while(j<=end)
           temp[k++]=a[j++];
       for(i=0;i<k;i++)
           a[first+i]=temp[i];
   }
   void mergesort(int a[],int first,int end,int temp[])
   {
       int mid;
       if(first<end)
       {
           mid=(end+first)/2;
           mergesort(a,first,mid,temp);
           mergesort(a,mid+1,end,temp);
           mergearray(a,first,mid,end,temp);
       }
   }
   int main()
   {
       int a[]={12,13,19,9,5,12,8,7,4,11,2,6,21}; //13
       int b[13],i;
       mergesort(a,0,12,b);
       for(i=0;i<13;i++)
           printf("%d ",a[i]);
       printf("\n");
   
       return 0;
   }
   
   

 

归并排序的效率是比较高的，设数列长为N，将数列分开成小数列一共要logN步，每步都是一个合并有序数列的过程，时间复杂度可以记为O(N)，故一共为O(N*logN)。因为归并排序每次都是在相邻的数据中进行操作，所以归并排序在O(N*logN)的几种排序方法（快速排序，归并排序，希尔排序，堆排序）也是效率比较高的。

 

注：有的书上是在mergearray()合并有序数列时分配临时数组，但是过多的new操作会非常费时。因此作了下小小的变化。只在MergeSort()中new一个临时数组。后面的操作都共用这一个临时数组