快速排序、归并排序、堆排序三种算法性能比较

快速排序、归并排序、堆排序三种排序算法的性能谁最好呢？网上查了一下说快速排序最快、其次是归并排序，最差的是堆排序；而理论上三种排序算法的时间复杂度都是O(nlogn)，只不过快速排序最差的会达到O(n^2)，但是数据的随机性会消除这一影响，今天就来实际比较一下：

#include <iostream>
#include<time.h>
using namespace std;
#define MAX 100000000
int data1[MAX],data2[MAX],data3[MAX],temp[MAX];
 //快速排序
void QuickSort(int data[],int i,int j)
{
    if(i>=j) return;
    int low = i;
    int high = j;
     int key = data[low];
     while(low<high)
     {
           while(high>low && data[high]>=key) --high;
           data[low] = data[high];
           while(low<high && data[low]<key) ++low;
           data[high] = data[low];
     }
     data[low] = key;
     QuickSort(data,i,low-1);
     QuickSort(data,low+1,j);
}
//归并排序

void MergeJudge(int data[],int first,int mid,int last,int temp[])
{
       int k=0;
       int i=first,j = mid+1;
       while(i<=mid && j<=last)
       {
           if(data[i] < data[j])
               temp[k++] = data[i++] ;
           else
               temp[k++] = data[j++] ;
       }
       while(i<=mid) temp[k++] = data[i++];
       while(j<=last) temp[k++] = data[j++];
       for(int i = 0;i<k;i++) data[first+i] = temp[i];
}

void MergeSort(int data[],int first,int last,int temp[])
{
    if(first>=last) return;
    int mid = (first + last) /2;
    MergeSort(data,first,mid,temp);
    MergeSort(data,mid+1,last,temp);
    MergeJudge(data,first,mid,last,temp);
}

inline void swap(int& a,int& b)
{
    int t = a;
    a = b;
    b = t;
}
//堆排序
void HeapJudge(int data[],int index,int n)
{
    while(index<n)
    {
          int left = index * 2 + 1;
          int right = index * 2 + 2;
          int max = index;
          if(left<n && data[max] < data[left])  max = left;
          if(right<n && data[max] < data[right]) max = right;
          if(max == index) break;
          swap(data[max],data[index]);
          index = max;
    }                                                       
}



void HeapSort(int data[],int n)
{
     for(int i=n/2-1 ; i>=0 ; i--)
     {
         HeapJudge(data,i,n);
     }
     for(int i = n-1;i>=0;i--)
     {
         swap(data[0],data[i]);
         HeapJudge(data,0,i);
     }
}

void print(int data[],int n)
{
    for(int i=0;i<n;i++)
    {
        printf("%d ",data[i]);
    }
    printf("
");
}
bool check(int data[],int n)
{
     for(int i=0;i<n-1;i++)
     {
         if(data[i]>data[i+1]) return false;
     }
     return true;
}
int main()
{
srand(unsigned int(time(0)));
    while(1)
    {

       int n;
       scanf("%d",&n);
       for(int i=0;i<n;i++)
       {
           data1[i] = rand();
           data2[i]=data1[i];
           data3[i]=data1[i];
       }
      printf("数据数量：%d
",n);
      double start = clock();
      QuickSort(data1,0,n-1);
      double end = clock();
      if(n<=10) print(data1,n);
      printf("快速排序：%.02lf ms
",end-start);
      if(!check(data1,n)) printf("快速排序出错！");

      start = clock();
      MergeSort(data2,0,n-1,temp);
      end = clock();
      if(n<=10) print(data2,n);
      printf("归并排序：%.02lf ms
",end-start);
      if(!check(data2,n)) printf("归并排序出错！");

      start = clock();
      HeapSort(data3,n);
      end = clock();
      if(n<=10) print(data3,n);
      printf("堆排序：%.02lf ms
",end-start);
      if(!check(data3,n)) printf("堆排序出错！");
    }

      return 0;
}

从上面数据可以看得出来：在数据量小的时候快速排序当属第一，堆排序最差，但随着数据的不断增大归并排序的性能会逐步赶上并超过快速排序，性能成为三种算法之首。可能在数据量大到一定数量时，快速排序的堆栈开销比较大，所以在性能上大打折扣，甚至堆排序的性能也能好过它，但总体上来说快速排序表现的还是比较优秀的。