三種基本排序的實現及其效率對比：冒泡排序、選擇排序和插入排序

public class ThreeTypesOfBaseSort {
　　//    ========================== 三種基本排序的效率對比 ============================
　　public static void main(String[] args) {
　　　　ThreeTypesOfBaseSort sort = new ThreeTypesOfBaseSort();

　　　　// 測試百萬級別的數組排序，看三種基本排序的的效率差別：
　　　　int number = 500000;
　　　　int[] array = new int[number];
　　　　int[] array1 = new int[number];
　　　　int[] array2 = new int[number];
　　　　for(int i = 0; i < array.length; i++) {
　　　　　　int temp = new Random().nextInt(number);
　　　　　　array[i] = temp;
　　　　　　array1[i] = temp;
　　　　　　array2[i] = temp;
　　　　}
　　　　System.out.println("數組准備完畢~");

　　　　long start1 = System.currentTimeMillis();
　　　　sort.bubbleSort(array);
　　　　long end1 = System.currentTimeMillis();
　　　　System.out.println("bubbleSort 用時：" + (end1 - start1));//測試結果：當元素個數為5萬時：4157。50萬：430255。100萬：1644079

　　　　long start2 = System.currentTimeMillis();
　　　　sort.selectionSort(array1);
　　　　long end2 = System.currentTimeMillis();
　　　　System.out.println("selectSort 用時：" + (end2 - start2));//5萬：727。50萬：74253。100萬：281276 ==》選擇排序比冒泡快了5.7倍。

　　　　long start3 = System.currentTimeMillis();
　　　　sort.insertionSort(array2);
　　　　long end3 = System.currentTimeMillis();
　　　　System.out.println("insertionSort 用時：" + (end3 - start3));//5萬：827。50萬：84644。 ==》插入排序比選擇排序稍慢一點。
　　}

　　//    ========================== BubbleSort ============================
　　/**
　　* 冒泡排序：相鄰的兩個數進行比較，如果是從小到大排序，則將較大的那個數放后，每次都要交換。

　　* 冒泡排序的優化思路：
　　* 　　    ① 判空；
　　* 　　    ② 元素的個數很特殊時：個數為0、1時；
　　* 　　    ③ 數組已經是有序的，或者是數組里所有元素都相同：
　　*/
　　public void bubbleSort(int[] target){
　　　　if(target == null){
　　　　　　return;
　　　　}
　　　　boolean tag = true;//如果數組是有序的，則不需要再進行交換。
　　　　for(int i = 0; i < target.length -1 && tag; i++){//外層循環：控制比較的組數：（元素個數-1）次。
　　　　　　tag = false;
　　　　　　for(int j = 0; j < target.length - i - 1; j++){//內層循環：控制比較的元素：每組比較都從第一個元素開始比較，把每次比較時的max移到后面去，每組的比較次數=target.length-1-i。
　　　　　　　　if(target[j] > target[j + 1]){
　　　　　　　　　　int temp = target[j];
　　　　　　　　　　target[j] = target[j + 1];
　　　　　　　　　　target[j + 1] = temp;
　　　　　　　　　　tag = true;
　　　　　　　　}
　　　　　　}
　　　　}
　　}

　　//    ======================= SelectionSort ============================
　　/**
　　* 選擇排序：
　　* 　　第一趟從n個元素的數據序列中選出關鍵字最小/大的元素並放在最前位置，
　　* 　　下一趟從n-1個元素中選出最小/大的元素並放在未排好序元素的最前位置。以此類推，經過n-1趟完成排序。
　　*/
　　public void selectionSort(int[] target){
　　　　if(target == null){
　　　　　　return;
　　　　}
　　　　for(int i = 0; i < target.length - 1; i++){
　　　　　　int tempIndex = i;
　　　　　　for(int j = i + 1; j < target.length; j++){
　　　　　　　　if(target[tempIndex] > target[j]){
　　　　　　　　　　tempIndex = j;
　　　　　　　　}
　　　　　　}
　　　　int temp = target[tempIndex];
　　　　target[tempIndex] = target[i];
　　　　target[i] = temp;
　　　　}
　　}

　　//    ===================== insertSort ====================================
　　/**
　　* 插入排序：將一個數據插入到已經排好序的有序數據中（一般默認第一個元素是有序的，比較從第二個元素開始），
　　* 從而得到一個新的、個數加一的有序數據，算法適用於少量數據的排序。
　　*/
　　public void insertionSort(int[] target){
　　　　if(target == null){
　　　　　　return;
　　　　}
　　　　//外層循環控制比較的組數；
　　　　for(int i = 0; i < target.length - 1; i++){
　　　　　　//內層循環負責找出該組比較中，在已排好序數組之后的第一個無序的元素，並通過比較將這個無序元素插入到有序數組中。
　　　　　　for(int j = i + 1; j > 0; j--){
　　　　　　　　if(target[j - 1] > target[j]){
　　　　　　　　　　int temp = target[j];
　　　　　　　　　　target[j] = target[j - 1];
　　　　　　　　　　target[j - 1] = temp;
　　　　　　　　}else{
　　　　　　　　　　break;
　　　　　　　　}
　　　　　　}
　　　　}
　　}
}

測試結果：

　　時間單位：毫秒
　　1. 冒泡排序：5萬個元素的排序：4157。  50萬：430255。  100萬：1644079
　　2. 選擇排序：5萬：727。                         50萬：74253。     100萬：281276
　　3. 插入排序：5萬：827。                         50萬：84644。
　　4. 快速排序：5萬：11。                           50萬：66。            100萬：136。

總結：
　　選擇排序 > 插入排序 > 冒泡排序；
　　選擇排序比插入排序快了1.1倍，比冒泡排序快了越5.7倍。