常见经典排序算法

常见经典排序算法
1.希尔排序  n的1.2次幂 不稳定
2.二分插入法
3.直接插入法  O(n*n)  稳定
4.带哨兵的直接排序法
5.冒泡排序  O(n*n)   稳定
6.选择排序   O(n*n)  不稳定
7.快速排序   log2(n)*n  不稳定
8.堆排序    log2(n)*n  不稳定

归并排序：log2(n)*n  稳定

一.希尔（Shell）排序法（又称宿小增量排序，是1959年由D.L.Shell提出来的）

#include

void sort(int v[],int n)
{
     int gap,i,j,temp;
     for(gap=n/2;gap>0;gap /= 2)
     {
          for(i=gap;i
          {
               for(j=i-gap;(j >= 0) && (v[j] > v[j+gap]);j -= gap )
               {
                temp=v[j];
                v[j]=v[j+gap];
                v[j+gap]=temp;
               }
          }
     }
}

二.二分插入法

void HalfInsertSort(int a[], int len)
{
     int i, j,temp;
     int low, high, mid;
     for (i=1; i
     {
          temp = a[i];
          low = 0;
          high = i-1;
          while (low <= high)
          {
               mid = (low + high) / 2;
               if (a[mid] > temp) 
               {
                high = mid-1;
               }
               else   
               {
                low = mid+1;
               }
          }      
          for (j=i-1; j>high; j--)
          {
           a[j+1] = a[j];
          }
          a[high+1] = temp;
     }
}

三.直接插入法

void InsertionSort(int input[],int len)
{
     int i,j,temp;
     for (i = 1; i < len; i++)
     {
          temp = input[i]; 
          for (j = i - 1;j>-1&&input[j] > temp ; j--)
          {
               input[j + 1] = input[j];
               input[j] = temp;
          }
     }
}

四.带哨兵的直接排序法

 
void InsertionSortWithPiquet(int input[],int len)
{
     int i,j;
     for (i = 2; i < len; i++) 
     {
          input[0] = input[i];
          for (j = i - 1; input[j] > input[0] ; j--)
          {
               input[j + 1] = input[j];
               input[j] = input[0];
          }
     }
}

五.冒泡法

void Bublesort(int a[],int n)
{
     int i,j,k;
     for(j=0;j
     {
          for(i=0;i
          {
               if(a[i]>a[i+1]) 
               {
                    k=a[i];
                    a[i]=a[i+1];
                    a[i+1]=k;
               }
          }
     }
}

六.选择排序法

void Selectsort(int A[],int n)
{
     int i,j,min,temp;
     for(i=0;i
     {
          min=i;
          for(j=i+1;j<=n;j++) 
          {
               if(A[min]>A[j]) 
               {
                temp=A[i];
                A[i]=A[j];
                A[j]=temp;
               }
          }
    }
}

七.快速排序

void Quick_sort(int data[],int low,int high)
{
 int mid;
 if(low
 {
  mid=Partition(data,low,high);
  Quick_sort(data,low,mid-1);
  Quick_sort(data,mid+1,high);
 }
}

int Partition(int data[],int low,int high)
{
 int mid;
    data[0]=data[low];
 mid=data[low];
 while(low < high)
 {
  while((low < high) && (data[high] >= mid))
  {
   --high;
  }
  data[low]=data[high];
 
  while((low < high) && (data[low] < mid))
  {
   ++low;
  }
  data[high]=data[low]; 
 }
 data[low]=data[0];   
 return low;    
}

八.堆排序

void HeapAdjust(int data[],int s,int m)
{
     int j,rc;
     rc=data[s];    
     for(j=2*s;j<=m;j*=2)       
     {
          if(j
          if(rc>data[j]) break;
          data[s]=data[j];  
          s=j;
     }
    data[s]=rc;    
}

void Heap_sort(int data[],int long_n)
{
     int i,temp;
     for(i=long_n/2;i>0;--i) 
     {
      HeapAdjust(data,i,long_n);
     }
     for(i=long_n;i>0;--i)
     {
      temp=data[1];   
      data[1]=data[i];
      data[i]=temp;  
      HeapAdjust(data,1,i-1);
     }
}

每个算法有什么优缺点，可以参照百度文库

地址：
http://wenku.baidu.com/view/c3054c0f7cd184254b353516.html

本文转载：http://blog.csdn.net/wengwuzi/archive/2008/10/05/3017968.aspx