冒泡排序（Bubble Sort）及優化

原理介紹

冒泡排序算法的原理以下：

1. 比較相鄰的元素。若是第一個比第二個大，就交換他們兩個。
2. 對每一對相鄰元素作一樣的工做，從開始第一對到結尾的最後一對。在這一點，最後的元素應該會是最大的數。
3. 針對全部的元素重複以上的步驟，除了最後一個。
4. 持續每次對愈來愈少的元素重複上面的步驟，直到沒有任何一對數字須要比較。

代碼實現

public static void sort1(int[] arr) {
    //比較的輪數
    for (int j = 0; j < arr.length - 1; j++) {
        //每輪比較的次數
        for (int i = 0; i < arr.length - 1 - j; i++) {
            if (arr[i] > arr[i + 1]) {
                int temp = arr[i];
                arr[i] = arr[i + 1];
                arr[i + 1] = temp;
            }
        }
    }
}

優化一

當某一輪排序沒有移動任何元素證實已經排好序，直接結束排序。如 {1,2,3,4,5,6,7,8,10,9} 第二輪排序後結束排序

代碼實現

//當一輪比較中沒有移動元素說明已經排好序，提早結束排序
public static void sort2(int[] arr) {
    int temp = 0;
    boolean flag;//標記是否進行了位置交換
    //比較的輪數
    for (int j = 0; j < arr.length - 1; j++) {
        flag = true;
        //每輪比較的次數
        for (int i = 0; i < arr.length - 1 - j; i++) {
            if (arr[i] > arr[i + 1]) {
                temp = arr[i];
                arr[i] = arr[i + 1];
                arr[i + 1] = temp;
                flag = false;
            }
        }
        if (flag) {
            //沒有發生位置交換，說明已經排好序
            return;
        }
    }
}

優化二

每輪排序中記下最後一個交換的位置，則此位置後面的元素已經有序，無需再遍歷

代碼實現

//經過交換的最後一個元素肯定已有序的位置，縮短每輪排序的長度
public static void sort3(int[] arr) {
    int temp = 0;
    int index = arr.length - 1;//當前排序的兩個元素中後一個的位置
    int temp2 = 0;
    boolean flag;//標記是否進行了位置交換
    //比較的輪數
    for (int j = 0; j < index; j++) {
        flag = true;
        //每輪比較的次數
        for (int i = 0; i < index; i++) {
            if (arr[i] > arr[i + 1]) {
                temp = arr[i];
                arr[i] = arr[i + 1];
                arr[i + 1] = temp;
                flag = false;
                temp2 = i;
            }
        }
        index = temp2;
        if (flag) {
            //沒有發生位置交換，說明已經排好序
            return;
        }
    }
}

優化三（雙向冒泡排序）

每輪中正向掃描找到最大值交換到最後，反向掃描找到最小值交換到最前面。例如： {1,2,3,4,5,6,0}

代碼實現

//一輪排序中，從前向後將最大元素移到最後，從後向前將最小元素移到最前
public static void sort4(int[] arr) {
    int left = 0;//未排序元素中最小下標
    int right = arr.length - 1;//未排序元素中最大下標
    int index_left = left;//從後向前排序中發生位置移動的兩個元素中後一個元素下標
    int index_right = right;//從前向後排序中發生位置移動的兩個元素中前一個元素下標
    int temp = 0;
    boolean flag;//標記是否進行了位置交換
    //最小下標與最大下標重合，排序結束
    while (left < right) {
        flag = true;
        //從前向後排出最大
        for (int i = left; i < right; i++) {
            if (arr[i] > arr[i + 1]) {
                temp = arr[i];
                arr[i] = arr[i + 1];
                arr[i + 1] = temp;
                flag = false;
                index_right = i;
            }
        }
        right = index_right;
        //從後向前排出最小
        for (int i = right; i > left; i--) {
            if (arr[i] < arr[i - 1]) {
                temp = arr[i];
                arr[i] = arr[i - 1];
                arr[i - 1] = temp;
                flag = false;
                index_left = i;
            }
        }
        left = index_left;
        if (flag) {
            //沒有發生位置交換，說明已經排好序
            return;
        }
    }
}