比较常用的排序方法（升序）：
冒泡排序：最常用的排序方法。大体思路就是每次选出一个最大值，第二次选出次大值，基本上就是两个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
来源：https://www.cnblogs.com/havePassed/p/3585375.html