各種排序的比較

1）插入排序

    每次將一個待排序的資料元素，插入到前面已經排好序的數列中的適當位置，使數列依然有序，直到待排序資料元素全部插入完為止

//假定a[0...i-1]有序，a[i]為待插入元素void insertSort(int a[],int n){int i,j,k;for(i=1;i!=n;++i){//為a[i]在前面的a[0...i-1]有序區間中找一個合適的位置for(j=i-1;j>=0;--j){if(a[j]<a[i])//找到第一個比a[i]小的元素的位置break;}if(j!=i-1)//需要進行後移的情況{int temp=a[i];for(k=i-1;k>j;k--)a[k+1]=a[k];a[j+1]=temp;}}}//將搜尋和資料後移這兩個步驟合并void insertSort2(int a[],int n){int i,j;for(i=1;i<n;++i){if(a[i]<a[i-1]){int temp=a[i];for(j=i-1;j>=0 && a[j]>temp;j--)a[j+1]=a[j];a[j+1]=temp;}}}//如果將資料插入換成資料交換void insertSort3(int a[],int n){int i,j;for(i=1;i<n;++i)for(j=i-1;j>=0&&a[j]>a[j+1];--j)swap(a[j],a[j+1]);}

2）選擇排序

    每一趟從待排序的資料元素中選出最小（大）的一個元素，順序放在已排好序列之後，直到全部排序的元素排完（和初始序列沒關係）

//直接選擇排序void selectSort(int a[],int n){int i,j,minIndex;for(i=0;i<n;i++){minIndex=i;for(j=i+1;j<n;j++){if(a[j]<a[minIndex])minIndex=j;}swap(a[i],a[minIndex]);}}inline void swap(int &a,int &b){int c=a;a=b;b=c;}

3）冒泡排序

       兩兩比較待排序資料元素的大小，發現兩個資料元素次序相反就交換，直到一趟中不再發生交換，排序結束

void bubbleSort(int a[],int n)  {      for(int i=0;i<n;++i)      {          for(int j=1;j<n-i;++j)              if(a[j-1]>a[j])                  swap(a[j-1],a[j]);      }  } 

      根據冒泡排序結束的條件可對代碼進行最佳化。

void bubbleSort(int a[],int n)  {      bool flag=true;      int k=n;      while(flag)      {          flag=false;          for(int j=1;j<k;++j)          {              if(a[j-1]>a[j])              {                  swap(a[j-1],a[j]);                  flag=true;              }          }          k--;      }  }  

4）快速排序

     在當前無序區R[1..H]任取一個資料元素作為比較的基準(記為X)，用此基準將當前的無序區劃分為兩個較小的無序區R[1..I-1],R[I+1,H]，且左邊無序區中的資料元素都小於等於X，右邊的無序區中的資料元素都大於基準元素。而基準X則位於最終排序的位置上。當R[1..I-1]和R[I+1,H]都非空時，再對 它們進行如上劃分，直至所有資料區中的元素都排序完全。（待排序列越無序，演算法效率越高）

int adjustArray(int s[],int l,int r){int i=l,j=r;int x=s[l];while(i<j){//從右向左找小於x的數來填s[i]while(i<j&&s[j]>=x)j--;if(i<j)//要時刻注意邊界{s[i]=s[j];i++;}//從左向右找大於或等於x的數來填s[j]while(i<j&&s[i]<x)i++;if(i<j){s[j]=s[i];j--;}}s[i]=x;return i;}//分治法的代碼void quick_sort1(int s[],int l,int r){if(l<r){int i=adjustArray(s,l,r);quick_sort1(s,l,i-1);quick_sort1(s,i+1,r);}}//整理之後void quick_sort(int s[],int l,int r){if(l<r){int i=l,j=r,x=s[l];while(i<j){while(i<j&&s[j]>=x)j--;if(i<j)s[i++]=s[j];while(i<j&&s[i]<x)i++;if(i<j)s[j--]=s[i];}s[i]=x;quick_sort(s,l,i-1);quick_sort(s,i+1,r);}}int main(){int arr[10]={12,3,5,-1,4,8,3,2,1,0};quick_sort(arr,0,9);for(int i=0;i!=10;i++)cout<<arr[i]<<" ";cout<<endl;return 0;}

        快速排序每次將待排序數組分為兩個部分，在理想狀況下，每一次都將待排序數組劃分成等長兩個部分，則需要logn次劃分。

        在最壞的情況下，即數組有序或基本有序的情況下，每次劃分只能減少一個元素，快速排序將不幸退化為冒泡排序，所以快速排序時間下界為O(nlogn)上界為O(n^2)

        快速排序的平均時間複雜度為O(nlogn)

        排序過程中只會花常數級的空間。空間複雜度為O(1)

5）堆排序

       推排序是一樹形選擇排序，在排序過程中，將R[1..N]看成是一棵完全二叉樹的順序儲存結構，利用完全二叉樹中雙親節點和孩子節點之間的內在聯絡選擇最小的元素。每一趟排序的基本操作是：將當前無序區調整為一個大頂堆，選取關鍵字最大的堆頂記錄，將它和無序區中最後一個記錄交換

     堆排序的最壞時間為O(log2n)，這是它相對於快速排序的最大優點，同時它的空間複雜度為O(1)，在所有時間複雜度為O(nlog2n)的排序中也是最小的。

6）希爾排序

        希爾排序又叫縮小增量排序，其本質還是插入排序，只不過將待排序的序列按某種規則分成幾個子序列，分別對這幾個子序列進行直接插入排序。最後以增量1分割整個序列，其實就是最整個序列進行一趟直接插入排序，從而完成整個希爾排序。

void shellSort(int a[],int n){int i,j,gap;//步長for(gap=n/2;gap>0;gap/=2) {for(i=0;i<gap;++i)  //這裡就是直接插入排序了，只不過每次排序的位置都是和gap有關的{for(j=i+gap;j<n;j+=gap){int temp=a[j];int k=j-gap;while(k>=0&&a[k]>temp){a[k+gap]=a[k];k-=gap;}a[k+gap]=temp;}}}}

7）折半插入排序

        折半插入排序的思想和直接插入排序一樣，區別在於尋找插入位置的方式不同。從直接插入排序的流程中可以看出，每次都是在一個已經有序的序列中插入一個新的記錄，所以在這個有序序列中尋找插入位置，就可以用折半尋找的方式進行。

8）二路歸併排序

      歸併排序採用分治法

     將原始序列看成N個只含有一個元素的子序列，顯然這些子序列都是有序的。兩兩歸併，形成若干二元組，再將這個序列看成若干個二元組子序列。繼續兩兩歸併，形成若干有序四元組.......不停的這樣歸併，最後會使整個序列變得有序。

     首先考慮將兩個序列合并

    

//合并數列的效率是比較高的，可以達到O(n)void mergeArray(int a[],int n,int b[],int m,int c[]){int i,j,k;i=j=k=0;while(i<n&&j<m){if(a[i]<b[m])c[k++]=a[i++];elsec[k++]=b[j++];}while(i<n)c[k++]=a[i++];while(j<m)c[k++]=b[j++];}

       歸併排序就是將數組分成兩組A，B，如果這兩組組內的資料都是有序的，那麼就可以很方便的將這兩組資料進行排序。

       先通過遞迴分解數列，再合并數列就完成了歸併排序。

//將兩個有序數列a[first...mid]和a[mid...last]合并void mergearray(int a[],int first,int mid,int last, int temp[]){int i=first,j=mid+1;int m=mid,n=last;int k=0;while(i<=m&&j<=n){if(a[i]<=a[j])temp[k++]=a[i++];elsetemp[k++]=a[j++];}while(i<=m)temp[k++]=a[i++];while(j<=n)temp[k++]=a[j++];for(i=0;i<k;i++)a[first+i]=temp[i];}void mergesort(int a[],int first, int last, int temp[]){if(first<last){int mid=(first+last)/2;mergesort(a,first,mid,temp);mergesort(a,mid+1,last,temp);mergearray(a,first,mid,last,temp);}}bool MergeSort(int a[],int n){int *p=new int[n];if(p==NULL)return false;mergesort(a,0,n-1,p);delete[] p;return true;}

     

--------------------------------------------------------------------------------------------------------------------------------------------------

時間複雜度：

        平均時間：快速排序，希爾排序，歸併排序和堆排序為O(nlog2n)，其它都是O(n*n)

        最壞時間：快速排序為O(n*n)，其它都和平均時間相同

空間複雜度：

       快速排序O(log2n)，歸併排序O(n)，基數排序O(rd)，其它都是O(1)

穩定性：

       快速排序，簡單選擇排序，希爾排序，堆排序這四種是不穩定的，其它都是穩定的