常见排序方法
比较常用的排序方法（升序）：
冒泡排序：最常用的排序方法。大体思路就是每次选出一个最大值，第二次选出次大值，基本上就是两个for循环。
鸡尾酒排序：冒泡排序方法的变种，鸡尾酒排序，待排序数组首先从0->n-1找出最大值，然后n-2->0找出最小值，然后再从1->n-2找次大值……依次类推……一个while循环，里面套两个for循环即可。
奇偶排序：也是冒泡排序的变种。一个while循环，里面两个for循环，但是一个for循环从0开始，一个从1开始，每次加2，比较相邻两个数值大小。
快速排序：是分之思想的一种体现。对于一个待排序队列，首先选择一个基准，扫描数据，大于这个基准数据的元素放在右侧，小于的放在左侧，然后左侧和右侧的数据又是待排序队列，再分别选择基准……递归下去，知道全部都是有序的。
插入排序：是一种比较直观的排序方法，从待排序队列中构建有序队列，把剩余的待排序数据插入到有序队列中。
希尔排序：分步长排序法，对相隔步长的数据分别进行排序，然后减小步长，直至步长为1，主要可以减少数据的移动次数。
选择排序：选择一个最大元素放入队尾，然后从剩余的元素中选择最大的放入队尾的前一位置，直到待排序数组中只有一个元素为止。
堆排序算法：选择排序的一种，不停的构建大（小）顶堆，然后取出顶，得到有序序列。
归并排序：也是典型的分治法思想的应用，是把两个有序的序列合并成一个有序序列。其中这两个有序序列分别是有两个有序序列合并而成。
基数排序：是一种比较型整数排序算法，把待比较的数值按照位数切割成不同的数值，从权值小的位开始比较大小，每个位数分别比较。
| 分类 | 排序方法 | 稳定性 | 平均时间复杂度 | 空间复杂度 |
| 交换排序 | 冒泡排序 | 稳定 | O(n2) | O(1) |
| 鸡尾酒排序 | 稳定 | O(n2) | O(1) | |
| 奇偶排序 | 稳定 | O(n2) | O(1) | |
| 快速排序 | 不稳定 | O(nlogn) | O(logn)~O(n) | |
| 插入排序 | 直接插入排序 | 稳定 | O(n2) | O(1) |
| 希尔排序 | 不稳定 | O(n1.25) | O(1) | |
| 选择排序 | 选择排序 | 不稳定 | O(n2) | O(1) |
| 堆排序 | 不稳定 | O(nlogn) | O(1) | |
| 归并排序 | 归并排序 | 稳定 | O(nlogn) | O(n) |
| 分布排序 | 基数排序 | 稳定 | O(nd)d为位数 | O(nd) |
还有一种比较好用的排序方法是二叉树排序法，是插入排序的一种，平均时间复杂度也不高，而且还能够方便的动态查找。在某些动态查找应用中可以很方便的应用。关于二叉树排序方法可以参考如下链接，我在后续的文章中也会具体写二叉排序树的相关操作。
常见排序方法：
#ifndef SORT_H_INCLUDED #define SORT_H_INCLUDED /**定义了各种排序方法 增序**/ void swap(int *a,int *b) { int temp=*a; *a=*b; *b=temp; } ///冒泡排序 void bubbling_sort(int * array,int len) { int i,j; for(i=0;i<len,i++) { for(j=0;j<len-1-i;j++) { if(array[j]>array[j+1]) { swap(array[j],array[j+1]); } } } } ///快速排序 int partion(int *arr, int left, int right) { int pValue=arr[left],pos=left,i=left; swap(&arr[left],&arr[right]);///保存在最后一个单元里面 while(i++<right-1) { if(arr[i]<pValue) { swap(&arr[i],&arr[pos++]); } } swap(&arr[right],&arr[pos]); return pos; } //递归实现 void quickSort1(int *arr, int left, int right) { int p=0; if(left<right) { p=partion(arr,left,right); quickSort1(arr,left,p-1); quickSort1(arr,p+1,right); } }
//非递归实现
void quickSort2(int *arr,int left,int right)
{
stack<int> positions;
int pos,l,r;
if(left<right){//首先计算一次，把下次要计算的位置压入栈中
pos=partion(arr,left,right);
if(pos-1>left){
positions.push(left);
postions.push(pos-1);
}
if(pos+1<right){
positions.push(pos+1);
positions.push(right);
}
}
while(!positions.empty()){//依次从栈中取出数据，进行分割
r=positions.top();
positions.pop();
l=positions.top();
positions.pop();
pos=partion(arr,l,r);
if(pos-1>left){
positions.push(left);
postions.push(pos-1);
}
if(pos+1<right){
positions.push(pos+1);
positions.push(right);
}
}
}
///堆排序 void heapfiy(int arr, int current, int heap_size) { int l=2*current+1,r=2*current+2,largest=current; if(l<heap_size&&arr[l]>arr[largest]) { largest=l; } if(r<heap_size&&arr[r]>arr[largest]) { largest=r; } if(largest!=current) { swap(&arr[largest],&arr[current]); heapfiy(arr,largest,heap_size); } } void build_heap(int *arr,int len) { int i; for(i=(len-2)/2;i>=0;i--) { heapfiy(arr,i,len); } } void heapSort(int *arr,int len) { int i=0; build_heap(arr,len); for(i=len-1;i>=0;i--) { swap(&arr[0],&arr[i]); heapfiy(arr,0,i); } } //归并排序 void merge_min(int* arr1,int len1,int* arr2, int len2) { int *tempSpace=(int*)malloc(sizeof(int)*(len1+len2)); int i=0,j=0,k=0; while(i<len1&&j<len2){ if(arr1[i]<arr2[j]){ tempSpace[k++]=arr1[i++]; } else { tempSpace[k++]=arr2[j++]; } } while(i<len1){ tempSpace[k++]=arr1[i++]; } while(j<len2){ tempSpace[k++]=arr2[j++]; } for(k=0;k<len1+len2;k++){ arr1[k]=tempSpace[k]; } free(tempSpace); } void merge_sort(int *arr,int n) { if(n<=1) return; int half=n/2; merge_sort(arr,half); merge_sort(arr+half,n-half); merge_min(arr,half,arr+half,n-half); } #endif // SORT_H_INCLUDED
http://www.cnblogs.com/sdlypyzq/archive/2011/09/10/2172937.html
