常用的内部排序方法(Java语言实现)

package cn.by.Struct.Sort;

public class Sort {

 /**
  *  插入排序    
  *  
  *  基本思想：
  *  每一趟将一个待排序的记录，按其关键字值的大小插入到已经排序的
  *  部分文件中适当位置上，直到全部插入完成。                         
  */ 
 
 /**
  * 直接插入排序（插入法）
  *
  * 逐个将纪录插入到已排好次序的有序表中得到一个新的有序表.
  *
  */
 public static void  chaSort(int[] table) {
  int i,j;
  int shao;//哨兵位
  for(i = 1; i < table.length; i++) {//要从下标为1的元素开始
   
   shao = table[i];//每次把当前元素赋给哨兵位
   j = i - 1;//j每次为有序表的最后一个元素，哨兵位要从它开始比起
   
   while(j >= 0 && shao < table[j]) {//控制边界，大小判断找到位置
    table[j + 1] = table[j];//元素后移，以便空出一个位置插入shao
    j--;//下一次循环    
   }
   table[j + 1] = shao;//找到位置，插入shao,为什么是j+1呢？因为在while退出的
   //时候，j的位置是指向小于或等于shao的元素，所以shao的位置j要加1
      
  }
 
 }
 
 
 /**
  * 希尔（shell）排序
  *
  * 基本思想：
  *
  * 把记录按下标的一定增量d分组，对每组记录采用直接插入排序方法进行排序，随着增量逐渐减小，所分成的组包
  * 含的记录越来越多，当增量的值减小到1时，整个数据合成为一组，构成一组有序记录，则完成排序。
  *
  * @param table
  * @param n 元素个数
   */
 public static void shellSort(int table[], int n) {
  
  int i;
  int j;
  int shao;//哨兵位
  int gap = n/2;//初始增量为长度减1
  while(gap > 0) {
   
   for(i = gap; i < n; i++) {//对所有相隔gap位置的所有元素进行排序
    shao = table[i];//每次把当前元素赋给哨兵位
    j = i - gap;//j每次为有序表的最后一个元素，哨兵位要从它开始比起
    while(j >= 0 && shao < table[j]) {//对相隔gap位置的元素组进行排序
     table[j + gap] = table[j];//元素后移，以便空出一个位置插入shao
     j = j - gap;//下一次循环 
    }
    
    table[j + gap] = shao;//找到位置，插入shao,为什么是j+gap呢？因为在while退出的
    //时候，j的位置是指向小于或等于shao的元素，所以shao的位置j要加gap
   }
   gap = gap/2;//
  }
   
  
 }
 
 
 
 
 
 
 
 /**
  * 选择排序
  *
  * 基本思想：
  * 每步从待排序的记录中选出关键字最小的记录，按顺序放在已排序的记录序列的最后，
  * 直到全部排完为止。
  *                       
  */

 /**
  * 直接选择排序
  *
  * 进行n-1趟，每一趟逐个与剩余元素比较，找到小的就与之交换。
  */
 public static void selectSort(int table[]) {
  
  int temp;//用于交换
  
  for(int i = 0; i < table.length - 1; i++) {
   for(int j = i + 1; j < table.length; j++ ){
    if(table[i] > table[j]) {
     temp = table[i];
     table[i] = table[j];
     table[j] = temp;
    }
     
   }
  }
  
 }
 
 
 
 
 
 
 
 
 
 
 
 /**
  *交换排序
  * 
  *基本思想:
  *两两比较待排序记录的关键字，并交换不满足次序要求的那些偶对，直到全部满足为止。                              
  */
  
   /**
    *冒泡排序 
    *
    *相邻之间相比较.n个元素要进行n-1趟。每趟要比较n减该趟（当前趟）次。
    *
    *从后向前冒，冒出最小的数
    *@param   array 要查的一个数组
    *@return  无返回值
    */
 public static void maoSort(int[] table) {

  /**
   *主要用于提前结束比较,即如果一趟中没有一个元素交换， 则后面还没有进行的趟也不用进行了。
   */
  int exchange;
  // 临时交换变量
  int temp;

  for (int i = 1; i <= table.length - 1; i++) {//要走的趟数
   exchange = 0; // 初始值为0
   for (int j = table.length - 1; j > i - 1; j--)//每趟要交换的次数
    if (table[j] < table[j - 1]) {
     temp = table[j];
     table[j] = table[j - 1];
     table[j - 1] = temp;
     exchange = 1; // 如有交换则更改为1
    }
   // 提前结束
   if (exchange == 0)
    return;
  }
 }

  
     /**
      *快速排序：
      *
      *通过一趟排序将待排序记录分割成独立的两部分，
      *其中一部分记录的关键字均比另一部分的关键字小，再分别
      *对这两部分记录继续进行排序，以达到整个序列有序。
      *
      *@param  table-待排序数组
      *@param  begin-待排序的起始源点
      *@param  end-待排序的终止点    
      */    
     public static void quickSort(int []table, int begin, int end) {
      
      //异常处理，待排序的起始源点不能小于0且不能大于待排序的终止点
       if((begin < 0) || (begin > end))
       return;
      
       int i = begin;
       int j = end;
       int tem;
       //存放界点,用区间的第一个元素作基准
      tem = table[begin]; 
      
      //从区间两端交替向中间扫描，直至i=j为止
       while(i != j) {
        
         //从右向左扫描，找第一个小于tem的元素       
         while((j > i) && table[j] > tem)
           j--;        
        
         //从左向右扫描，找第一个大于tem的元素
         while((i < j) && table[i] < tem)
           i++;
          
         //满足条件交换         
         if(i < j) {
           int change;
           change = table[j];
           table[j] = table[i];
           table[i] = change;
         }       
       }
      
       //分成两部分记录
       table[i] = tem;
       //对界点前部分记录排序
      quickSort(table, begin, i - 1);
      //对界点后部分记录排序     
      quickSort(table, i + 1, end);
     }  
   
 
    
 

}