简单排序算法

package com.shine.sort;
/**
 * 排序算法   <br>
 * @说明：<br>
 *     排序算法分为三种：插入排序、交换排序、选择排序   <br>
 *     1.插入排序：直接插入排序、折半插入排序、希尔排序  <br>
 *     2.交换排序：冒泡排序、快速排序     <br>
 *     3.选择排序： 直接选择排序、堆排序  <br>
 */
public class MySort {


/**
* 直接插入排序<br>
* @描述：<br>
*        1. 直接插入排序是第i趟把第i个元素放的前面已经排好序的序列中去<br>
*        2. 重复上述操作。n个元素共需n-1趟扫描，每趟将一个元素插入到它前面的子序列中 <br>
* @复杂度分析：<br>
*     1.时间复杂度：<br> 
*        最好情况：当数据序列已排序，时间复杂度为o(n) <br>
*        最坏情况：数据序列反序，时间复杂度为o(n*n) <br>
*        随机：o(n*n)  <br>
*     2.空间复杂度：o(1)   <br>    
* @稳定性：稳定    
*/
public static void insertSort(int[] table){
for(int i=1;i<table.length;i++){//n-1趟扫描
int temp=table[i],j;//每趟将table[i]插入到前面排序序列中
for(j=i-1;j>=0&&temp<table[j];j--)
table[j+1]=table[j];//将较大元素向后移动
table[j+1]=temp;//temp到达插入位置
}
}
/**
* 希尔排序 <br>
* @描述： <br>
*      1.将一个数据序列分成若干组，每组由若干相隔一段距离的元素组成，这段距离称为增量，
*        在一组内采用直接插入排序算法进行排序       <br>
*      2.当增量为1时，只有一组，元素是整个序列，再进行一次直接插入排序即可     <br>
* @复杂度分析：
*      1.时间复杂度：时间复杂度比较复杂，具体时间取决于具体增量的序列   <br>
*      2.空间复杂度：o(1)
* @稳定性：不稳定 
*/
public static void shellSort(int[] table){
for(int delta=table.length/2;delta>0;delta/=2)//进行若干趟扫描，控制增量，增量减半
for(int i=delta;i<table.length;i++){//一趟分若干组，每组进行直接插入排序
int temp=table[i],j;
for(j=i-delta;j>=0&&temp<table[j];j-=delta)
table[j+delta] = table[j];
table[j+delta] = temp;
}
}
/**
* 冒泡排序 <br>
* @说明： <br>
*    比较两个相邻元素的关键值，如果反序，则交换。若按升序排序，每一趟将被扫描的数据序列中的最大元素交换到
*    最后位置，就像气泡从水里冒出一样。  <br>
* @复杂度分析：<br>
*    1.时间复杂度分析：o(n)-o(n*n)
*    2.空间复杂度分析：o(1)
* @稳定性：稳定  
*/
public static void bubleSort(int[] table){
boolean exchange = true;
for(int i=1;i<table.length&&exchange;i++){//有交换时才进行下一趟排序
exchange = false;//假定元素没有交换
for(int j=0;j<table.length-i;j++)
if(table[j]>table[j+1]){
int temp = table[j];
table[j] = table[j+1];
table[j+1] = temp;
exchange = true;
}
}
}
/**
* 快速排序算法  <br>
* @说明: <br>
* 在数据序列中选择一个值作为比较的基准值，每趟从数据序列的两端开始交替进行，将小于基准值的元素交换到序列
*      前段，大于基准值的元素交换到序列后端，介于两者之间的位置则称为基准值的最终位置。同时序列被划分成两个子
*      序列，在用同样的方法对两个子序列进行排序，直到子序列长度为1，则完成排序。
* @复杂度分析：  <br>
*      时间复杂度：<br>
*          最好情况：每趟排序将序列分成长度相近的两个子序列。   o(nlog2n)     <br>
*          最坏情况：每趟排序将序列分成长度差异很大的两个子序列   o(n*n)      <br>
*      空间复杂度：<br>
*       最好情况：  o(log2n)
*          最坏情况：  o(n)
* @稳定性:不稳定<br>
*/
   public static void quickSort(int[] table){
  quickSort(table,0,table.length-1);
   }
   private static void quickSort(int[] table,int begin,int end){
  if(begin<end){
  int i=begin,j=end;
  int vot=table[i];//基准值
  while(i!=j){//一趟排序
  while(i<j&&vot<=table[j])
  j--;
  if(i<j)//如果有小元素（当有table[j]<vot的时候，该条件恒成立）
  table[i++]=table[j];//把后面的小元素向前移动
  while(i<j&&table[i]<=vot)
  i++;
  if(i<j)
  table[j--]=table[i];//把大元素向后移动
  }
  table[i]=vot;//基准值到达最终位置
  quickSort(table,begin,j-1);//前段子序列进行排序
  quickSort(table,i+1,end);//后端子序列进行排序
  }
   }
   /**
    * 直接选择排序   <br>
    * @说明：<br>
    * 第一趟从n个元素的数据中选出关键字最小或最大的元素放到最前或最后位置，下一趟再从n-1个元素……。直接选择排序
    *       算法可用顺序表和单链表实现。   <br>
    * @复杂度：   <br>
    *       时间复杂度：o(n*n) <br>
    *       空间复杂度：o(1) <br>
    * @稳定性：不稳定 <br>
    */
   public static void selectSort(int[] table){
  for(int i=0;i<table.length-1;i++){
  int min=i;
  for(int j=i+1;j<table.length;j++)
  if(table[j]<table[min])
  min=j;
  if(min!=i){
  int temp=table[i];
  table[i]=table[min];
  table[min]=temp;
  }
  }
   }
   /**
    * 堆排序
    * @说明： <br>
    * 1.堆：这里的堆不是数据结构里面的堆栈，而是一种数据结构。堆可以视为一颗完全二叉树，完全二叉树的一个优秀的性质是
    *         除了最底层之外，每一层都是满的，这使得堆可以利用数组来表示，每一个节点对应数组中的一个元素。二叉堆一般分
    *         为两种，最小堆和最大堆。<br>
    *   2.最大堆：堆中每个父节点的值都大于等于其孩子节点，这样的堆就是一个最大堆。<br>
    *     最小堆：对中的每个父节点都小于等于其孩子节点，这样的堆就是一个最小堆。 <br>
    *   3.堆排序：堆排序分两个阶段。首先将一个数据序列建成堆序列，根节点值是最小（大）值；然后采用选择排序思路，每趟将
    *     根结点值交换到最后，再将其余值调整成堆，依次重复，直到排序完成。<br>
    * @复杂度：<br>
    * 时间复杂度：o(n*log2n)<br>
    *   空间复杂度：o(1) <br>
    * @稳定性：不稳定
    */
   
   public static void heapSort(int[] table){//堆排序
  int n=table.length;
  for(int j=n/2-1;j>=0;j--)//创建最小堆
  sift(table,j,n-1);
  for(int j=n-1;j>0;j--){//每趟将最小值交换到后面，再调整成堆
  int temp=table[0];
  table[0]=table[j];
  table[j]=temp;
  sift(table,0,j-1);
  }
   }
   //将以begin为根的子树调整成最小堆，begin、end是序列下届和上届
   private static void sift(int[] table,int begin,int end){
  int i=begin,j=2*i+1;//i为子树的根，j为i节点的左孩子
  int temp=table[i];//获得第i个元素的值
  while(j<=end){//沿较小值孩子节点向下筛选
  if(j<end&&table[j]>table[j+1])//数组元素比较
  j++; //j为左右孩子的较小者
  if(temp>table[j]){//若父母结点值较大
  table[i]=table[j];//孩子节点中的较小者上移
  i=j; //i,j向下一层
  j=2*i+1;
  }
  else break;
  }
  table[i]=temp;//当前子树的原根值调整后的位置
   }
   /**
    * 归并排序
    * @param args
    */
   //一次归并方法：   m和r分别是两个相邻的两个已排序的子序列的起始下标
   private static void merge(int[] X,int[] Y,int m,int r,int n){//一次归并
  int i=m,j=r,k=m;
  while(i<r&&j<r+n&&j<X.length){//将X中两个相邻子序列归并到Y中
  if(X[i]<X[j])//较小值复制到Y中
  Y[k++]=X[i++];
  else Y[k++]=X[j++];
  while(i<r) //将前一个子序列剩余元素复制到Y中
  Y[k++]=X[i++];
  while(j<r+n&&j<X.length)//将后一个子序列剩余元素复制到Y中
  Y[k++]=X[j++];
  }
   }
   //一趟归并
   private static void mergepass(int[] X,int[] Y,int n){//一趟归并
  int i=0;
  while(i<X.length-2*n+1){
  merge(X,Y,i,i+n,n);
  i+=2*n;
  }
  if(i+n<X.length)
  merge(X,Y,i,i+n,n);//再一次归并
  else
  for(int j=i;j<X.length;j++)//将X剩余元素复制到Y中
  Y[j]=X[j];
   }
   public static void mergeSort(int[] X){ //归并排序
  int[] Y = new int[X.length];
  int n=1;
  while(n<X.length){
  mergepass(X,Y,n);
  n*=2;
  if(n<X.length){
  mergepass(Y,X,n);
  n*=2;
  }
  }
   }
public static void main(String[] args) {
int[] table = {22,11,65,33,21,23,10};
System.out.println("直接插入排序：");
insertSort(table);
for(int x: table)
System.out.print(x+"\t");

System.out.println("\n希尔排序：");
shellSort(table);
for(int x: table)
System.out.print(x+"\t");

System.out.println("\n冒泡排序：");
bubleSort(table);
for(int x: table)
System.out.print(x+"\t");

System.out.println("\n快速排序：");
quickSort(table);
for(int x: table)
System.out.print(x+"\t");

System.out.println("\n直接选择排序：");
selectSort(table);
for(int x: table)
System.out.print(x+"\t");

System.out.println("\n堆排序：");
heapSort(table);
for(int x: table)
System.out.print(x+"\t");

System.out.println("\n归并排序：");
mergeSort(table);
for(int x: table)
System.out.print(x+"\t");


}


}