常用排序算法总结

注：所有排序都是写的由小到大排序的情况

1.插入排序

1）直接插入排序（稳定）

代码：

void DirectInsertSort(int* arr, int len){if(NULL==arr || len<=1)return;int keyIndex;//要插入的值下标for(keyIndex=1;keyIndex<len;++keyIndex){int key=arr[keyIndex]; //要插入的值int sortedIndex=keyIndex-1; //前面已经排好序的值的下标，由后往前比较while(sortedIndex>=0 && arr[sortedIndex]>key){arr[sortedIndex+1]=arr[sortedIndex];--sortedIndex;}arr[sortedIndex+1]=key;  //注意这里的下标 sortedIndex+1}}

2）希尔排序 （不稳定）

希尔排序好的增量序列的共同特征:

http://baike.baidu.com/view/178698.htm?fromtitle=希尔排序算法&fromid=1801475&type=syn

① 最后一个增量必须为1

② 应该尽量避免序列中的值(尤其是相邻的值)互为倍数的情况

代码：

void ShellSort(int* arr, int len){    if(NULL==arr || len<=1)return;    for (int gap = len / 2; gap > 0; gap /= 2)  //增量（gap/2.2时间效率更好）        for (int keyIndex = gap; keyIndex < len; ++keyIndex) //插入排序即为gap=1的情况        {              int key = arr[keyIndex];             int sortedIndex = keyIndex -gap;             while(sortedIndex >= 0 && arr[sortedIndex] > key)             {                arr[sortedIndex+gap] = arr[sortedIndex];sortedIndex -=gap;              }               arr[sortedIndex+gap] = key;         }}

2.选择排序

1）直接选择排序（不稳定）

第一次从R[0]~R[n-1]中选取最小值，与R[0]交换，第二次从R[1]~R[n-1]中选取最小值，与R[1]交换，....，第i次从R[i-1]~R[n-1]中选取最小值，与R[i-1]交换，.....，第n-1次从R[n-2]~R[n-1]中选取最小值，与R[n-2]交换，总共通过n-1次，得到一个按排序码从小到大排列的有序序列·

  初始状态 [ 8 3 2 1 7 4 6 5 ] 8 <--> 1

第一次 [ 1 3 2 8 7 4 6 5 ] 3 <--> 2

第二次 [ 1 2 3 8 7 4 6 5 ] 3 <--> 3

第三次 [ 1 2 3 8 7 4 6 5 ] 8 <--> 4

第四次 [ 1 2 3 4 7 8 6 5 ] 7 <--> 5

第五次 [ 1 2 3 4 5 8 6 7 ] 8 <--> 6

第六次 [ 1 2 3 4 5 6 8 7 ] 8 <--> 7

第七次 [ 1 2 3 4 5 6 7 8 ] 排序完成

代码：

void DirectChooseSort(int* arr, int len){if(NULL==arr || len<=1)return;for(int keyIndex=0;keyIndex<len-1;++keyIndex){int minIndex=keyIndex;for(int leftIndex=keyIndex+1;leftIndex<len;++leftIndex) //arr[keyIndex]~arr[len-1]最小值{if(arr[minIndex]>arr[leftIndex])minIndex=leftIndex;}if(minIndex!=keyIndex){int temp=arr[minIndex];arr[minIndex]=arr[keyIndex];arr[keyIndex]=arr[minIndex];}}}

2）堆排序（不稳定）---最大堆

最大堆性质：树中每个结点的值都大于或者等于任意一个子结点的值

代码：

给出了非递归和递归方法

//递归方法void MaxHeapify_Recursively(int* arr, int idx, int len){int leftIdx=2*idx+1;int rightIdx=2*idx+2;int maxIdx=idx;//idx，leftIdx和rightIdx中最小值的下标if(leftIdx<len && arr[maxIdx]<arr[leftIdx])maxIdx=leftIdx;if(rightIdx<len && arr[maxIdx]<arr[rightIdx])maxIdx=rightIdx;if(maxIdx!=idx){int temp=arr[idx];arr[idx]=arr[maxIdx];arr[maxIdx]=temp;MaxHeapify_Recursively(arr,maxIdx,len);}}//非递归循环方法void MaxHeapify_Iteratively(int* arr, int idx, int len){while(idx<len/2){int leftIdx=2*idx+1;int rightIdx=2*idx+2;int maxIdx=idx;//idx，leftIdx和rightIdx中最小值的下标if(leftIdx<len && arr[maxIdx]<arr[leftIdx])maxIdx=leftIdx;if(rightIdx<len && arr[maxIdx]<arr[rightIdx])maxIdx=rightIdx;if(maxIdx!=idx){int temp=arr[idx];arr[idx]=arr[maxIdx];arr[maxIdx]=temp;idx=maxIdx;}elsereturn;}}void BuildMaxHeap(int* arr, int len){for(int i=len/2-1;i>=0;--i)MaxHeapify_Recursively(arr,i,len);}void MaxHeapSort(int*arr, int len){if(NULL==arr || len<=1)return;BuildMaxHeap(arr,len);for(int i=len-1;i>=1;--i){int temp=arr[0];arr[0]=arr[i];arr[i]=temp;MaxHeapify_Recursively(arr,0,i);}}

3.交换排序

1）冒泡排序（稳定）

代码：

void BubbleSort(int *arr, int len){if(NULL==arr || len<=1)return;bool isOrdered=true;     //判断在一次冒泡过程时没有发生交换，即为已经排序好for(int i=1;i<len-1;++i) //冒泡找到第i大的数for(int j=0;j<len-i;++j){if(arr[j+1]<arr[j]){int temp=arr[j];arr[j]=arr[j+1];arr[j+1]=temp;isOrdered=false;}if(isOrdered)break;}}

2）快速排序（不稳定）

代码：（使用尾递归的随机化快排）

void Swap(int & a, int &b)  {      int temp=b;      b=a;      a=temp;  } int Partition(int *arr, int start, int end)  {      int index=rand()%(end-start+1)+ start; //产生[start,end]之间的随机整数    Swap(arr[index],arr[end]);       int small=start-1;    for(index=start;index<end;++index)      {          if(arr[index]<arr[end])          {              ++small;    if(small<index)Swap(arr[small],arr[index]);             }      }      ++small;    Swap(arr[small],arr[end]);     return small;  }void TailQuickSort(int *arr,int length, int start, int end)   //尾递归{  if(NULL==arr || length<=1 || start<0 || end>=length)return;while(start<end){int index=Partition(arr,start,end); if((index-start)<(end-index))  {TailQuickSort(arr,length, start,index-1); start=index+1; }  if((index-start)>=(end-index)) {  TailQuickSort(arr,length,index+1,end);  end=index-1;  }  }}

4.归并排序（稳定）

代码：

void Merge(int* arr, int start, int end, int leftEnd){int *pOrdered=new int[end-start+1];int index=0;int leftBegin=start;int rightBegin=leftEnd+1;while(leftBegin<=leftEnd && rightBegin<=end){if(arr[leftBegin]<=arr[rightBegin])pOrdered[index++]=arr[leftBegin++];elsepOrdered[index++]=arr[rightBegin++];}while(leftBegin<=leftEnd)pOrdered[index++]=arr[leftBegin++];while(rightBegin<=end)pOrdered[index++]=arr[rightBegin++];for(int i=0;i<index;++i)arr[start++]=pOrdered[i];delete[] pOrdered;pOrdered=NULL;}void MergeSort(int*arr, int len, int start, int end){if(NULL==arr || len<=1 || start<0 || end>=len)return;if(start<end){int leftEnd=(end+start)/2;MergeSort(arr, len, start, leftEnd);MergeSort(arr,len, leftEnd+1, end);Merge(arr, start, end, leftEnd);}}

5.线性时间排序

1）计数排序（稳定）

数组中每个数都在[0,k]之间

代码：

void CountSort(int *arr ,int len, int k){if(NULL==arr || len<=1 || k<0)return;int* countArr=new int[k+1];int* sortedArr=new int[len];for(int m=0;m<k+1;++m)countArr[m]=0;for(int i=0;i<len;++i)++countArr[arr[i]];for(int j=1;j<k+1;++j)countArr[j]+=countArr[j-1];for(int l=len-1;l>=0;--l){sortedArr[countArr[arr[l]]-1]=arr[l]; //注意这里的下标 countArr[arr[l]]-1--countArr[arr[l]];}for(int i=0;i<len;++i)arr[i]=sortedArr[i];delete[] countArr;countArr=NULL;delete[] sortedArr;sortedArr=NULL;}

2）基数排序

代码：

(以十进制为例，设每一位的排序基于计数排序的思想)

int MaxBits(int* arr, int len,int base) //辅助函数，求数据的最大位数{    int nMaxBits = 1;     for(int i = 0; i<len; ++i)    {        while(arr[i] >= base)        {            base *= 10;            ++nMaxBits;        }    }    return nMaxBits;}void RadixSort(int* arr, int len) //基数排序{if(NULL==arr || len<=1)return;int base=10;int nMaxBits= MaxBits(arr,len,base);int* countArr=new int[base+1];int* sortedArr=new int[len];int radix=1;for(int i=0;i<nMaxBits;++i)    //由低位到高位按照计数排序的思想排序{for(int m=0;m<base+1;++m)countArr[m]=0;for(int i=0;i<len;++i)++countArr[(arr[i]/radix)%base];for(int j=1;j<base+1;++j)countArr[j]+=countArr[j-1];for(int l=len-1;l>=0;--l){int bitNum=(arr[l]/radix)%base;sortedArr[countArr[bitNum]-1]=arr[l]; //注意这里的下标 countArr[bitNum]-1--countArr[bitNum];}for(int i=0;i<len;++i)arr[i]=sortedArr[i];radix*=10;}delete[] countArr;countArr=NULL;delete[] sortedArr;sortedArr=NULL;}

3）桶排序

代码：