資料結構與演算法——排序演算法-氣泡排序

天然呆dull 發表於 2021-08-29
演算法 資料結構

資料結構與演算法——排序演算法-氣泡排序

基本介紹

氣泡排序(Bubble Sorting)的基本思想:通過對待排序序列 從前向後(從下標較小的元素開始),依次比較相鄰元素的值,若發現逆序則交換,使值較大的元素逐漸從前移向後部,就像水底下的旗袍一樣逐漸向上冒。

優化點:因為排序過程中,個元素不斷接近自己的位置,如果一趟比較下來沒有進行過交換,就說明序列有序,因此要在排序過程中設定一個標誌判斷元素是否進行過交換。從而減少不必要的比較。(該優化點可以在完成基本的氣泡排序之後再做)

圖解氣泡排序演算法的過程

資料結構與演算法——排序演算法-氣泡排序

動圖:

資料結構與演算法——排序演算法-氣泡排序

氣泡排序小結:

  1. 共進行 陣列大小 - 1 次大的迴圈
  2. 每一趟排序的次數在逐漸的減少
  3. 優化:如果發現在某趟排序中,沒有發生一次交換,則可以提前結束氣泡排序。

程式碼實現

演變過程

為了容易理解,先演示氣泡排序的演變過程

    /**
     * 為了更好的理解,這裡把氣泡排序的演變過程演示出來
     */
    @Test
    public void processDemo() {
        int arr[] = {3, 9, -1, 10, -2};

        // 第 1 趟排序:將最大的數排在最後
        // 總共排序:arr.length - 1
        int temp = 0; // 臨時變數,交換的時候使用
        for (int i = 0; i < arr.length - 1; i++) {
            if (arr[i] > arr[i + 1]) {
                temp = arr[i];
                arr[i] = arr[i + 1];
                arr[i + 1] = temp;
            }
        }
        System.out.println("第 1 趟排序後的陣列");
        System.out.println(Arrays.toString(arr));

        // 第 2 趟排序:將第 2 大的數排在倒數第 2 位
        // 總共排序:arr.length - 1 - 1  ;
        // 從頭開始排序,其他沒有變化,只是將排序次數減少了一次
        for (int i = 0; i < arr.length - 1 -1; i++) {
            if (arr[i] > arr[i + 1]) {
                temp = arr[i];
                arr[i] = arr[i + 1];
                arr[i + 1] = temp;
            }
        }
        System.out.println("第 2 趟排序後的陣列");
        System.out.println(Arrays.toString(arr));

        // 第 3 趟排序:將第 3 大的數排在倒數第 3 位
        // 總共排序:arr.length - 1 - 2  ;
        // 從頭開始排序,其他沒有變化,只是將排序次數減少了 2 次
        for (int i = 0; i < arr.length - 1 -2; i++) {
            if (arr[i] > arr[i + 1]) {
                temp = arr[i];
                arr[i] = arr[i + 1];
                arr[i + 1] = temp;
            }
        }
        System.out.println("第 3 趟排序後的陣列");
        System.out.println(Arrays.toString(arr));

        // 第 4 趟排序:將第 4 大的數排在倒數第 4 位
        // 總共排序:arr.length - 1 - 3  ;
        // 從頭開始排序,其他沒有變化,只是將排序次數減少了 3 次
        for (int i = 0; i < arr.length - 1 -3; i++) {
            if (arr[i] > arr[i + 1]) {
                temp = arr[i];
                arr[i] = arr[i + 1];
                arr[i + 1] = temp;
            }
        }
        System.out.println("第 4 趟排序後的陣列");
        System.out.println(Arrays.toString(arr));

        // 第 5 趟沒有必要,因為這裡有 5 個數字,確定了 4 個數字,剩下的那一個就已經出來了
    }

測試輸出

第 1 趟排序後的陣列
[3, -1, 9, -2, 10]
第 2 趟排序後的陣列
[-1, 3, -2, 9, 10]
第 3 趟排序後的陣列
[-1, -2, 3, 9, 10]
第 4 趟排序後的陣列
[-2, -1, 3, 9, 10]

從上述的 4 趟排序過程來看,迴圈體都是一樣的,只是每次迴圈的次數在減少,那麼就可以如下簡化

@Test
public void processDemo2() {
  int arr[] = {3, 9, -1, 10, -2};

  // 總共排序:arr.length - 1
  int temp = 0; // 臨時變數,交換的時候使用
  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]) {
        temp = arr[i];
        arr[i] = arr[i + 1];
        arr[i + 1] = temp;
      }
    }
    System.out.println("第 " + (j + 1) + " 趟排序後的陣列");
    System.out.println(Arrays.toString(arr));
  }
}

測試輸出

第 1 趟排序後的陣列
[3, -1, 9, -2, 10]
第 2 趟排序後的陣列
[-1, 3, -2, 9, 10]
第 3 趟排序後的陣列
[-1, -2, 3, 9, 10]
第 4 趟排序後的陣列
[-2, -1, 3, 9, 10]

優化

對於優化,減少排序次數

    @Test
    public void processDemo3() {
        int arr[] = {3, 9, -1, 10, 20};

        // 總共排序:arr.length - 1
        int temp = 0; // 臨時變數,交換的時候使用
        boolean change = false;// 標識變數,表示是否進行過交換
        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]) {
                    temp = arr[i];
                    arr[i] = arr[i + 1];
                    arr[i + 1] = temp;
                    change = true;
                }
            }
            if(!change){
                // 如果有 1 輪下來,都沒有進行排序,則可以提前退出
                break;
            }else{
                change = false; // 重置 change!!!, 進行下次判斷
            }
            System.out.println("第 " + (j + 1) + " 趟排序後的陣列");
            System.out.println(Arrays.toString(arr));
        }
    }

測試輸出:

第 1 趟排序後的陣列
[3, -1, 9, 10, 20]
第 2 趟排序後的陣列
[-1, 3, 9, 10, 20]

這裡更改了原始陣列,因為優化的點,得看你這個陣列原來的排序 和 元素組成,算是一種概率問題,並不是在任何情況下都可以被優化

封裝演算法

    /**
     * 把排序演算法封裝成一個方法,方便被複用
     *
     * @param arr
     */
    public static void bubbleSort(int[] arr) {
        // 總共排序:arr.length - 1
        int temp = 0; // 臨時變數,交換的時候使用
        boolean change = false;
        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]) {
                    temp = arr[i];
                    arr[i] = arr[i + 1];
                    arr[i + 1] = temp;
                    change = true;
                }
            }
            if(!change){
                // 如果有 1 輪下來,都沒有進行排序,則可以提前退出
                break;
            }else{
                change = false; // 重置 change!!!, 進行下次判斷
            }
        }
    }

測試呼叫

    /**
     * 測試封裝後的演算法
     */
    @Test
    public void bubbleSortTest() {
        int[] arr = {3, 9, -1, 10, 20};
        System.out.println("排序前:" + Arrays.toString(arr));
        bubbleSort(arr);
        System.out.println("排序後:" + Arrays.toString(arr));
    }
    

測試輸出

排序前:[3, 9, -1, 10, 20]
排序後:[-1, 3, 9, 10, 20]

大量資料耗時測試

排序隨機生成的 8 萬個資料

    /**
     * 大量資料排序時間測試
     */
    @Test
    public void bulkDataSort() {
        int max = 80000;
        int[] arr = new int[max];
        for (int i = 0; i < max; i++) {
            arr[i] = (int) (Math.random() * 80000);
        }

        Instant startTime = Instant.now();
        bubbleSort(arr);
//        System.out.println(Arrays.toString(arr));
        Instant endTime = Instant.now();
        System.out.println("共耗時:" + Duration.between(startTime, endTime).toMillis() + " 毫秒");
    }

測試輸出

執行幾次,差不多在 13 秒左右
共耗時:14656 毫秒
共耗時:13853 毫秒