排序-基本排序算法

import java.io.InputStreamReader;
 import java.io.BufferedReader;
 /**
 * Class  SortDemo
 * Description  简单排序有insertSort,BubbleSort,SelectSort,ObjectSort
 *             复杂排序  shellSort,quickSort,baseSort
 * Company opendata
 * Author  Chenlly
 * Date  08-11-30
 * Version 1.0
 */
 public class SortDemo{
  private  int[] intArray;
  //构造方法
  public SortDemo(){
   intArray=new int[]{1000,10,65,23,887,28,97,65,43,2,7,9,188};
  }
  //显示排序后的数据
  public void display(){
   for(int i=0;i<intArray.length;i++){
    System.out.print(intArray[i]+",");
   }
  }
  //交换数据
  public void swap(int i,int j){
   int temp=0;
   temp=intArray[j];
   intArray[j]=intArray[i];
   intArray[i]=temp;
  }
  //(1)插入排序,对intArray[i]插入到左边intArray[0,i]局部有序的数组中适当的位置，使之
  //intArray[0,i+1]继续有序列
  public void insertSort(){
   for(int i=1;i<intArray.length;i++){
    int temp=intArray[i];//暂存临时变量
    int j=i;
    while(temp<intArray[j-1]){
     intArray[j]=intArray[j-1];//移动
     j--;
     if(j==0)break;
    }
    intArray[j]=temp;//temp已经找到正确的位置，插入。
   }
  }
  
  //(2)冒泡排序,最小的元素冒出来,相邻两数据比较
  public void bubbleSort(){
   for(int i=0;i<intArray.length;i++){
    for(int j=intArray.length-1;j>i;j--){
     if(intArray[j]<intArray[j-1]){
      swap(j,j-1);
     }
    for(int k=0;k<intArray.length;k++){
     System.out.print(intArray[k]+",");
    }
    System.out.println();
    }
   }
  }
  
  //(3)选择排序,对冒泡排序的改进，交换次数减少但总的比较时间还是O(N2)
  //在右边无序数组中intArray[j,n]选择一个最小的元素，然后和右边无序的第一个元素intArray[j]交换，
  //使得左边intArray[0,j+1]有序
  public void selectSort(){
   for(int i=0;i<intArray.length;i++){   int min = i;
    for(int j=i+1;j<intArray.length;j++){
     if(intArray[min]>intArray[j]){
      swap(min,j);
     }
    }
   }
  }
  //(4)希尔排序对插入排序的改进 间隔序列 h=h*3+1
  //间隔序列内做插入排序，直到最后h等于1此时是普通的插入排序
  public void shellSort(){
   int h=1;
   while(h>0){
    h=h*3+1; 
   }
   for(int i=h;i<intArray.length;i++){
    int j=i;
    int temp=intArray[i];
    while(j>h-1&&temp>intArray[j-h]){
     intArray[j]=intArray[j-h];
     j=j-h;
    }
    //找到合适的位置
    intArray[j]=temp;
   }//end for
   h=(h-1)/3;
  }
  //(5)快速排序对冒泡排序的改进,对一个值快速定位，使左边的值都比它小，右边的值都比它大
  /*
  首先你的脑子里先浮现一个数组和三个指针，第一个指针称为p指针，
  在整个过程结束之前它牢牢的指向第一个数，第二个指针和第三个指针分别为lo指针和hi指针，
  分别指向最左边的值和最右边的值。lo指针和hi指针从两边同时向中间逼近，
  在逼近的过程中不停的与p指针的值比较，如果lo指针的值比p指针的值小，lo++，还小还++，再小再++，
  直到碰到一个大于p指针的值，这时视线转移到hi指针，如果 hi指针的值比p指针的值大，hi--，还大还--，
  再大再--，直到碰到一个小于p指针的值。这时就把lo指针的值和hi指针的值做一个调换。
  持续这过程直到两个指针碰面，这时把p指针的值和碰面的值做一个调换，然后返回p指针新的位置。
  */
  //O(N*logN)
  public void quickSort(){
   reQuickSort(0,intArray.length-1);
  }
  
  public void reQuickSort(int left,int right){
   if(right<=left){
    return;//return用在此处仅仅做为一个方法的结束
   }else{
    int pivot=intArray[right];//枢纽,每次把最右边的元素作为枢纽
    int midIndex=partition(left,right,pivot);//枢纽对于的恰当的位置
    reQuickSort(left,midIndex-1);
    reQuickSort(midIndex+1,right);
   }
  }
  
  public int partition(int left,int right,int pivot){
   int vleft=left;
   int vright=right-1;
   while(true){
     //持续比较直到左边某个的值大于枢纽
    while(intArray[vleft]<intArray[pivot]){
     vleft++;
    }
    //持续比较直到右边某个值小于枢纽
    while(intArray[pivot]<intArray[vright]){
     vright--;
    }
    //比较结束,交换枢纽和intArray[vleft]值
    if(vright<vleft){
     break;
    }else{
     //如果最终比较还没结束需交换刚才停止的两个值
     swap(vleft,vright);
    }
   }//end while(true)
   swap(vleft,right);
   return vleft;
  }
  //(6)基数排序
  public void baseSort(){
  
  }
  //主调函数
  public static void main(String args[]){
   SortDemo sd=new SortDemo();
   System.out.println("请简单选择排序算法：");
   System.out.println("1 插入排序");
   System.out.println("2 冒泡排序");
   System.out.println("3 选择排序");
   System.out.println("请高级选择排序算法：");
   System.out.println("4 希尔排序");
   System.out.println("5 快速排序");
   System.out.println("6 基数排序");
   System.out.println("请输入编号");;
   String str="";
   try{
    InputStreamReader ir=new InputStreamReader(System.in);
    BufferedReader br=new BufferedReader(ir);
    str=br.readLine();
   }catch(Exception ex){
    ex.printStackTrace();
   }
   int op=Integer.parseInt(str);
   switch(op){
    case 1: sd.insertSort();break;
    case 2: sd.bubbleSort();break;
    case 3: sd.selectSort();break;
    case 4: sd.shellSort();break;
    case 5: sd.quickSort();break;
    case 6: sd.baseSort();break;
    default: break;
   }
   sd.display();
  }
 }