排序

一、插入排序
基本思想：每次将一个待排序的记录按其关键码的大小插入到一个已经排好序的有序序列中，直到全部记录排好序为止。

直接插入排序：
将一组数据分为有序序列与无序序列两类
通过比较，依次将无序序列中的元素置入有序序列中。
再插入第i（i>1）个元素时，前面i个元素已经排好序。

如何创建初始的有序序列？
a：
取数组r[]
r[0]：监视哨（防止数组越界）、暂存单元。
将第一个元素（r[1]）看作初始有序序列，之后依次增添。
如何查找待插入记录的插入位置？
a：
r[0]=r[i]; j=i-1;
while (r[0]<r[j])
{
r[j+1]=r[j];
j–;
}
算法实现：

void  insertSort (int  r[ ], int n){	
   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];	
    }
}

希尔排序
改进的依据：
（1）若待排序记录按关键码基本有序时，直接插入排序的效率可以大大提高；
（2）由于直接插入排序算法简单，则在待排序记录数量n较小时效率也很高。
基本思想：
将整个待排序记录分割成若干个子序列，
在子序列内分别进行直接插入排序，
待整个序列中的记录基本有序时，对全体记录进行直接插入排序。
问题：子序列内如何进行直接插入排序？
解决方法：
1.在插入记录r[i]时，自r[i-d]起往前跳跃式（跳跃幅度为d）搜索待插入位置，并且r[0]只是暂存单元，不是哨兵。当搜索位置＜0，表示插入位置已找到。
2.在搜索过程中，记录后移也是跳跃d个位置。
3.在整个序列中，前d个记录分别是d个子序列中的第一个记录，所以从第d+1个记录开始进行插入。
算法描述：

for (i=d+1; i<=n; i++)  //将r[i]插入到所属的子序列中
{
     r[0]=r[i];                     //暂存待插入记录 
     j=i-d;                   
     while (j>0 && r[0]<r[j])
     { 
          r[j+d]=r[j];       //记录后移d个位置
          j=j-d;            //比较同一子序列的前一个记录
      }
      r[j+d]=r[0]; 
}

最终代码实现：

void Shellsort(int r[],int n){
  for (d=n/2; d>=1; d=d/2){
     for (i=d+1; i<=n; i++) {
	     r[0]=r[i];           
	     j=i-d;                
	     while (j>0 && r[0]<r[j])
	     { 
          		r[j+d]=r[j]; 
	          j=j-d;          
	      }
	      r[j+d]=r[0]; 
	}
  }

二、交换排序
起泡排序：
基本思想：两两比较相邻记录的关键码，如果反序则交换，直到没有反序的记录为止。

void BubbleSort(int r[ ], int n)
{	
    exchange=n; 	
    while (exchange) 
    {
        bound=exchange; 
        exchange=0；  
        for (j=1; j<bound; j++)
            if (r[j]>r[j+1]) {
                r[j]←→r[j+1]；
	      exchange=j； 
            }
     }
 }

快速排序：
首先选一个轴值（即比较的基准），
通过一趟排序将待排序记录分割成独立的两部分，
前一部分记录的关键码均小于或等于轴值，
后一部分记录的关键码均大于或等于轴值，
然后分别对这两部分重复上述方法，直到整个序列有序。
实现一次划分：

int Partition(int r[ ], int first, int end)
{	
    i=first; j=end;         //初始化
    r[0]=r[i];
     while (i<j)	
    {  
      while (i<j && r[0]<= r[j]) j--；  //右侧扫描
       if (i<j) { 
          r[i]=r[j];   i++;  //将较小记录交换到前面
       }
       while (i<j && r[i]<= r[0]) i++；  //左侧扫描
       if (i<j) {
          r[j]=r[i];   j--;  //将较大记录交换到后面
       }
    }
    r[i]=r[0];
    retutn i;    //i为轴值记录的最终位置
}

处理分割得到的两个待排序子序列：

void QuickSort (int  r[ ], int first, int end )
{
    pivotpos = Partition (r, first, end );  //一次划分  
   //对前一个子序列进行快速排序
    QuickSort (r, first, pivotpos-1);      
   //对后一个子序列进行快速排序
   QuickSort (r, pivotpos+1, end ); 
}

判别快速排序的结束：

void QuickSort (int  r[ ], int first, int end )
{//在序列 first~end中递归地进行快速排序
    if (first < end) {					
          pivotpos = Partition (r, first, end );    
          QuickSort (r, first, pivotpos-1);
          QuickSort (r, pivotpos+1, end );
   }
}