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++];
else
c[k++]=b[j++];
}
while(i<n)
c[k++]=a[i++];
while(j<m)
c[k++]=b[j++];
}先通過遞歸分解數列，再合併數列就完成了歸併排序。
//將兩個有序數列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++];
else
temp[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)
穩定性：
快速排序，簡單選擇排序，希爾排序，堆排序這四種是不穩定的，其它都是穩定的
