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;
    }
   }
  }
 }
 
}