C++实现排序算法

稳定性：快速 希尔 选择 堆排序不稳定

时间复杂度：平均情况下，快速、希尔、归并和堆排序的时间复杂度均为O(nlog2(n))，其他都是O(n^2)。最坏情况下，快排的时间复杂度为O(n^2)

 #include <iostream>
 #include <stdlib.h>
 #include <time.h>
 #define N 1000
 using namespace std;

 //输出
 void output(int a[], int num){
     for(int i=;i<num;i++){
         cout<<a[i]<<" ";
     }
     cout<<endl;
 }

 //交换元素位置
 void swap(int a[], int index1, int index2){
     int tmp = a[index1];
     a[index1] = a[index2];
     a[index2] = tmp;
 }

 //快速排序
 void quickSort(int a[], int l, int r, int num){
     if(l<r){
         int left = l;
         int right = r;
         int tmp = a[l];
         while(left<right){
             while(left<right && a[right]>=tmp){
                 right--;
             }
             if(left<right){
                 a[left++] = a[right];
             }
             while(left<right && a[left]<=tmp){
                 left++;
             }
             if(left<right){
                 a[right--] = a[left];
             }
         }
         a[left] = tmp;
         //output(a,num);
         quickSort(a,l,left-,num);
         quickSort(a,left+,r,num);
     }
 }

 //冒泡排序
 void bubbleSort(int a[], int num){
     int i,j;
     int flag = ;
     for(i=num-;i>;i--){
         flag = ;
         for(j=;j<i;j++){
             if(a[j]>a[j+]){
                 swap(a,j,j+);
                 flag=;
             }
         }
         if(flag==){
             break;
         }
     }
 }

 //选择排序
 void selectSort(int a[], int num){
     int right,i;
     int maxIndex;
     for(right=num-;right>;right--){
         maxIndex = ;
         for(i=;i<right;i++){
             if(a[maxIndex]<a[i]){
                 maxIndex = i;
             }
         }
         swap(a,maxIndex,right);
     }

 }

 //建立大顶堆
 void buildHeap(int a[], int index, int len){
     int curParent = a[index];
     int child = index *  +;
     while(child<len){
         if(child+<len && a[child]<a[child+]){
             child++;
         }
         if(curParent < a[child]){
             a[index] = a[child];
             //这里不用把curParent赋值给child，因为还要迭代子树，如果孩子中有更大的，会上移，curParent还要继续下移
             index = child;
             child = child *  +;
         } else {
             break;
         }
     }
     a[index] = curParent;
 }

 /*
 void buildHeap(int a[], int i, int len){
     int parent = a[i];
     int left = i*2+1;
     while(child < len){
         if(child+1<len && a[child]<a[child+1]){
             child++;
         }
         if(parent<a[child]){
             a[i] = child;
             child = 2*i+1;
         } else {
             break;
         }
     }
     a[p] = parent;
 }*/

 //堆排序
 void heapSort(int a[], int num){
     int i;
     for(i=num/-;i>=;i--){
         buildHeap(a, i, num);
     }
     for(i=num-;i>=;i--){
         int max = a[];
         a[] = a[i];
         a[i] = max;
         buildHeap(a,,i);
     }

 }
 //插入排序
 void insertSort(int a[], int num){
     int i,j,tmp;
     for(i=;i<num;i++){
         tmp = a[i];
         for(j=i-;j>=;j--){
             if(a[j]>tmp){
                 a[j+] = a[j];
             } else {
                 break;
             }
         }
         a[j+] = tmp;
     }
 }

 void merge(int a[], int first, int mid, int last){
     int *tmp = (int *)malloc((last-first+)*sizeof(int));
     int i = first;
     int j = mid+;
     int k = ;
     while(i<=mid && j<=last){
         if(a[i]<=a[j]){
             tmp[k++] = a[i++];
         } else {
             tmp[k++] = a[j++];
         }
     }
     while(i<=mid){
         tmp[k++] = a[i++];
     }
     while(j<=last){
         tmp[k++] = a[j++];
     }
     for(i=first;i<=last;i++){
         a[i] = tmp[i-first];
     }
     free(tmp);
 }

 void mergeSort(int a[], int first, int last){
     int mid = (first+last)/;
     if(first<last){
         mergeSort(a,first,mid);
         mergeSort(a,mid+,last);
         merge(a,first,mid,last);
     }
 }

 int main(){
     int num;
     while(cin>>num){
         int i;
         start = clock();
         int *arr = new int[num];
         for(int i=; i<num; i++){
             arr[i] = rand()%;
             //cin>>arr[i];
         }
         cout<<"待排序数组为:"<<endl;
         output(arr,num);

         //quickSort(arr,0,num-1,num);            //快速排序
         //bubbleSort(arr,num);                    //冒泡排序
         //selectSort(arr,num);                    //归并排序
         //insertSort(arr,num);                    //插入排序
         //heapSort(arr,num);                    //堆排序
         //mergeSort(arr,0,num-1);                //归并排序
         stop = clock();
         cout<<stop-start<<endl;

         cout<<"排序后的数组为:"<<endl;
         output(arr,num);

     }
     return ;
 }