java基础之几种排序算法

public class Sort {
 public static void main(String args[]){
  
  int len =8;
  int arr[] = new int [len];
  for(int i = 0;i<arr.length;i++){
   //arr[i] = new int[];
   arr[i]=(int)(Math.random()*10000);
  }
  
//  Bubble b = new Bubble();
// // int arr[] = {1,-34,-3,100,3};
//  System.out.println("冒泡排序前"+new Date());
//  b.sort(arr);
//  System.out.println("冒泡排序后"+new Date());
// 
//     Select s = new Select();
//     System.out.println("选择排序前"+new Date());
//     s.sortSelect(arr);
//     System.out.println("选择排序后"+new Date());
     
//     QuickSort qs = new QuickSort();
//     System.out.println("快速排序前"+new Date());
//     qs.sort(0, arr.length-1, arr);
//     System.out.println("快速排序后"+new Date());
     
  Insert in = new Insert();
  System.out.println("插入排序前"+new Date());
  in.sort(arr);
  System.out.println("插入排序后"+new Date());
  
     for(int i = 0;i<arr.length;i++){
      System.out.println(arr[i]);
     }
 }
}
/**
 * 插入排序的基本思想：每次将一个待排序的记录，
 * 按其关键字的大小插入到前面已经排好序的子文件的适当位置，
 * 直到     所有的记录插入完成为止
 * @author chenweisong
 *
 */
class Insert{//插入排序法
 public void sort(int arr[]){
  int insert;
  int index;
  for (int i = 1; i < arr.length; i++) {
   insert = arr[i];
   index = i;
  while(index > 0 && arr[index-1]>arr[index]){
   int temp;
   temp = arr[index-1];
   arr[index-1]=arr[index];
   arr[index] = temp;
   index--;
   
  }
  }
  
 }
}
/**
 * 快速排序（Quicksort）是对冒泡排序的一种改进。
 * 由C. A. R. Hoare在1962年提出。它的基本思想是：
 * 经过一趟排序将要排序的数据分割成独立的两部分，
 * 其中一部分的全部数据都比另一部分的全部数据都要小，
 * 而后再按此方法对这两部分数据分别进行快速排序，整个排序过程能够递归进行，
 * 以此达到整个数据变成有序序列。
 * @author chenweisong
 *
 */
class QuickSort{
 public void sort(int left,int right,int arr[]){
  
  if(left < right){
   int key = arr[left];
   int low = left;
   int hight = right;
   while(low < hight){
    while(low < hight && arr[hight]>key){
     hight--;
    }
    arr[low] = arr[hight];
    while(low < hight && arr[low]<key){
     low++;
    }
    arr[hight] = arr[low];
   }
   arr[low] = key;
   sort(left,low-1,arr);
   sort(low+1,right,arr);
   
  }else{
   return;
  }
 }
}
/**
 * 每一趟从待排序的数据元素中选出最小（或最大）的一个元素，
 * 顺序放在已排好序的数列的最后，直到所有待排序的数据元素排完。
 *  选择排序是不稳定的排序方法。
 * @author chenweisong
 *
 */
class Select{
 public void sortSelect(int arr[]){//选择排序
  for(int i = 0;i<arr.length-1;i++){//要排序多少趟
   int min = arr[i];
   //int temp = i;
   for(int j = i+1;j<arr.length;j++){//每次要比较多少次。（j=i+1，是由于每比较一次，最小数就产生一个，接下来不必参加比较）
    
    if(min>arr[j]){
       int temp;
       temp = min;
       min = arr[j];
       arr[j]= temp;
    }
   }
   arr[i]=min;
  }
 }
}
/**
 *  冒泡排序算法的运做以下：（从后往前）
           比较相邻的元素。若是第一个比第二个大，就交换他们两个。
           对每一对相邻元素做一样的工做，从开始第一对到结尾的最后一对。在这一点，最后的元素应该会是最大的数。
 针对全部的元素重复以上的步骤，除了最后一个。
 持续每次对愈来愈少的元素重复上面的步骤，直到没有任何一对数字须要比较
 * @author chenweisong
 *
 */
class Bubble{
 
 public void sort(int arr[]){//冒泡排序
  int temp;
  for(int i = 0;i<arr.length-1;i++){//要跑多少趟
   for( int j =0;j<arr.length-1;j++){//每次要比较多少次
    if(arr[j]>arr[j+1]){
     temp = arr[j];
     arr[j] = arr[j+1];
     arr[j+1] = temp;
    }
   }
  }
 }
 
 public void sortSeo(int arr[]){//冒泡排序优化算法
  int temp;
  for(int i = 0;i<arr.length-1;i++){//要跑多少趟
   for( int j =0;j<arr.length-1-i;j++){//每次要比较多少次
    if(arr[j]>arr[j+1]){
     temp = arr[j];
     arr[j] = arr[j+1];
     arr[j+1] = temp;
    }
   }
  }
 }
 
}