C数据结构之排序

选择排序
===============================================
void  SelectSort(RecordType r[], int length)
{ n=length;
   for ( i=1 ; i<= n－1; ++i)  
     { k=i;
       for ( j=i+1 ; j<= n ; ++j)  
          if (r[j].key < r[k].key )  k=j;
          if ( k!=i) /*如果k在循环中改变了，就需要交换数据*/
              { x= r[i]; r[i]= r[k]; r[k]=x; }
       }
   }
================================================
 直接插入排序
================================================
void insert_sort(int *r, int n)
{
    int i, j, t;
    for (i=2; i<=n; i++) {
        r[0]=r[i];  j=i-1;
　　      While(r[0]<r[j]){
　　       r[j+1]=r[j];  j=j-1;
　　     }
　　r[j+1]=r[0];
　　}
}
================================================
 冒泡排序
=================================================
void bubble_sort(recordtype r[ ], int n); 
{  i= n;
   while ( i >1)
      {  laste=1;
         for  (j=1; j<i; j++)
           if (r[j+1].key < r[j].key) 
              {  x=r[j]; r[j]=r[j+1]; r[j+1]=x;
                laste= j;  {记下进行交换的记录位置}
               }  
        i= laste; {本趟最后一次进行交换的记录位置} 
       }
}
================================================
 希尔排序
=====================================================
Void shellinsert(recordtype r[ ], int length, int d )
 { 
     for(i=1+d; i<=length; i++) 
      if(r[i].key < r[i-d].key) 
        {  r[0]=r[i];       /*备份r[i]*/
           for(j=i-d;j>0&&r[0].key< r[j].key;j-=d) //查找r[i]的插入位置
                 r[j+d]=r[j]; //后移记录
           r[j+d]=r[0];}/*插入r[i]到正确的位置上*/
        }      
Void shellsord(recordtype r[ ], int length, int d[], int n) 
{ 
     for (i=0;i<=n-1,++i)
     shellinsert(r,length, d[i] );
}    
================================================
 快速排序
=====================================================
int QKpass(recordtype r[ ], int s, int t)/*本算法对r[s..t]进行一趟快速排序*/
 {  x=r[s]; i=s; j=t;   
    while  (i<j)            /*low用i表示, high用j表示*/
      { while (i<j)&&(r[j].key>=x.key)  j=j-1;   
         r[i]=r[j];     
        while (i<j)&&(r[i].key<=x.key)  i=i+1;   
         r[j]=r[i];    
      }
     r[i]=x;   
	 return i;  
 }       
void QKsort(recordtype r[ ], int low, int high); /*对记录序列r[low.. high]进行快速排序*/
{   if  (low < high){ 
		pos=QKpass(r,low,high);/*对 r[low.. high] 进行一趟划分,pos为枢轴*/
		QKsort(r,low,pos-1);   /*对低子序列递归排序*/
		QKsort(r,pos+1,high); /*对高子序列递归排序*/
		} 
}
================================================
 堆排序
void   crt_heap(RecordType r[], int length ) /*对记录数组r建堆，length为数组的长度*/
{   n= length;
    for ( i=n/2 ; i>= 1 ; --i)
        sift(r，i，n) ;
 } 
void  HeapSort（RecordType  r[],int length）   /* 对r[1..n]进行堆排序*/ 
{   crt_heap(r, length); 
    n= length;
   for (  i=n  ; i>= 2 ; --i) 
     { b=r[1]; r[1]= r[i]; r[i]=b; /* 将堆顶记录和堆中最后一个记录互换 */ 
       sift(r，1，i-1);  /* 进行筛选,使r[1..i-1]成为堆 */ 
     }  
}
================================================
归并排序
void Merge ( RecordType r1[],  int low,   int mid,   int high,  RecordType  r[])
/*r1[low..mid]和r1[mid+1..high]分别有序，将它们合并*/
{   i=low;j=mid+1; k=low;
    while ( (i<=mid)&&(j<=high)  )  
     {
	 if ( r1[i].key<=r1[j].key ){
		  r[k]=r1[i] ; ++i;
		  }
      else 	
          { 
		  r[k]=r1[j] ; ++j;
		  }
           ++k ;   
    }
  while ( i<=mid )   r[k} =r1[i];k++;i++;
  while ( j<=high  ) r[k} =r1[j];k++;j++;
 }
void   MergeSort (RecordType  r1[],  int  low,  int  high,  RecordType  r[])
 /*r1[low..high]经排序后放在r[low..high]中,r2[low..high]为辅助空间 */ 
{   RecordType  r2 [hight-low+1] ;
   if ( low==high ) 
        r[low]=r1[low];
   else{mid=(low+high)/2;
         MergeSort(r1，low， mid,  r2);
         MergeSort(r1，mid+1，high,  r2);
         Merge (r2，low，mid，high， r);}
　　　}

排序方法	平均时间	最坏时间	辅助空间	稳定性
简单排序	O(n2)	O(n2)	O(1)	稳定
希尔排序	O(n3/2)		O(d[k])	非稳定
快速排序	O(nlogn)	O(n2)	O(logn)	非稳定
堆排序	O(nlogn)	O(nlogn)	O(1)	非稳定
归并排序	O(nlogn)	O(nlogn)	O(n)	稳定
基数排序	O(d*n)	O(d*n)	O(rd)	稳定