常见排序方法

比较常用的排序方法（升序）：

冒泡排序：最常用的排序方法。大体思路就是每次选出一个最大值，第二次选出次大值，基本上就是两个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

二叉查找树