快速排序、歸併排序、堆排序三種算法性能比較

快速排序、歸併排序、堆排序三種排序算法的性能誰最好呢？網上查了一下說快速排序最快、其次是歸併排序，最差的是堆排序；而理論上三種排序算法的時間複雜度都是O(nlogn)，只不過快速排序最差的會達到O(n^2)，可是數據的隨機性會消除這一影響，今天就來實際比較一下：

  1 #include <iostream>
  2 #include<time.h>
  3 using namespace std;
  4 #define MAX 100000000
  5 int data1[MAX],data2[MAX],data3[MAX],temp[MAX];
  6  //快速排序
  7 void QuickSort(int data[],int i,int j)
  8 {
  9     if(i>=j) return;
 10     int low = i;
 11     int high = j;
 12      int key = data[low];
 13      while(low<high)
 14      {
 15            while(high>low && data[high]>=key) --high;
 16            data[low] = data[high];
 17            while(low<high && data[low]<key) ++low;
 18            data[high] = data[low];
 19      }
 20      data[low] = key;
 21      QuickSort(data,i,low-1);
 22      QuickSort(data,low+1,j);
 23 }
 24 //歸併排序
 25 
 26 void MergeJudge(int data[],int first,int mid,int last,int temp[])
 27 {
 28        int k=0;
 29        int i=first,j = mid+1;
 30        while(i<=mid && j<=last)
 31        {
 32            if(data[i] < data[j])
 33                temp[k++] = data[i++] ;
 34            else
 35                temp[k++] = data[j++] ;
 36        }
 37        while(i<=mid) temp[k++] = data[i++];
 38        while(j<=last) temp[k++] = data[j++];
 39        for(int i = 0;i<k;i++) data[first+i] = temp[i];
 40 }
 41 
 42 void MergeSort(int data[],int first,int last,int temp[])
 43 {
 44     if(first>=last) return;
 45     int mid = (first + last) /2;
 46     MergeSort(data,first,mid,temp);
 47     MergeSort(data,mid+1,last,temp);
 48     MergeJudge(data,first,mid,last,temp);
 49 }
 50 
 51 inline void swap(int& a,int& b)
 52 {
 53     int t = a;
 54     a = b;
 55     b = t;
 56 }
 57 //堆排序
 58 void HeapJudge(int data[],int index,int n)
 59 {
 60     while(index<n)
 61     {
 62           int left = index * 2 + 1;
 63           int right = index * 2 + 2;
 64           int max = index;
 65           if(left<n && data[max] < data[left])  max = left;
 66           if(right<n && data[max] < data[right]) max = right;
 67           if(max == index) break;
 68           swap(data[max],data[index]);
 69           index = max;
 70     }                                                       
 71 }
 72 
 73 
 74 
 75 void HeapSort(int data[],int n)
 76 {
 77      for(int i=n/2-1 ; i>=0 ; i--)
 78      {
 79          HeapJudge(data,i,n);
 80      }
 81      for(int i = n-1;i>=0;i--)
 82      {
 83          swap(data[0],data[i]);
 84          HeapJudge(data,0,i);
 85      }
 86 }
 87 
 88 void print(int data[],int n)
 89 {
 90     for(int i=0;i<n;i++)
 91     {
 92         printf("%d ",data[i]);
 93     }
 94     printf("\n");
 95 }
 96 bool check(int data[],int n)
 97 {
 98      for(int i=0;i<n-1;i++)
 99      {
100          if(data[i]>data[i+1]) return false;
101      }
102      return true;
103 }
104 int main()
105 {
106 srand(unsigned int(time(0)));
107     while(1)
108     {
109 
110        int n;
111        scanf("%d",&n);
112        for(int i=0;i<n;i++)
113        {
114            data1[i] = rand();
115            data2[i]=data1[i];
116            data3[i]=data1[i];
117        }
118       printf("數據數量：%d\n",n);
119       double start = clock();
120       QuickSort(data1,0,n-1);
121       double end = clock();
122       if(n<=10) print(data1,n);
123       printf("快速排序：%.02lf ms\n",end-start);
124       if(!check(data1,n)) printf("快速排序出錯！");
125 
126       start = clock();
127       MergeSort(data2,0,n-1,temp);
128       end = clock();
129       if(n<=10) print(data2,n);
130       printf("歸併排序：%.02lf ms\n",end-start);
131       if(!check(data2,n)) printf("歸併排序出錯！");
132 
133       start = clock();
134       HeapSort(data3,n);
135       end = clock();
136       if(n<=10) print(data3,n);
137       printf("堆排序：%.02lf ms\n",end-start);
138       if(!check(data3,n)) printf("堆排序出錯！");
139     }
140 
141       return 0;
142 }

從上面數據能夠看得出來：在數據量小的時候快速排序當屬第一，堆排序最差，但隨着數據的不斷增大歸併排序的性能會逐步遇上並超過快速排序，性能成爲三種算法之首。可能在數據量大到必定數量時，快速排序的堆棧開銷比較大，因此在性能上大打折扣，甚至堆排序的性能也能好過它，但整體上來講快速排序表現的仍是比較優秀的。