冒泡排序

package com.jackhu.sort;

import java.util.Arrays;

/**
 * 冒泡排序
 * 兩兩比較，大的日後放
 * 時間複雜度 O
 * <p>
 * 能夠看到，在第2輪排序完成後，其實咱們就已經的到了排好序的數組，可是咱們的程序並不知道，仍然進行了後續的無用工做。那麼，咱們如何來讓程序知道已經完成好排序了呢？
 * <p>
 * 這裏能夠想到，當某一輪的兩兩比較中，若是都沒有發生數組元素的互換，那麼其實排序工做已經完成了，因此咱們能夠考慮在程序中加入一個flag，默認爲false，含義是該輪比較中是否發生了元素互換，當程序中執行到元素互換時，將該flag置爲true，當該輪比較結束時，若flag爲flase，則說明該輪比較未發生元素互換，那麼排序完成，若flag爲true，說明本輪比較仍然有元素互換，須要繼續進行下輪排序。代碼實現以下：
 * <p>
 * 冒泡排序是一種用時間換空間的排序方法，最壞狀況是把順序的排列變成逆序，或者把逆序的數列變成順序。在這種狀況下，每一次比較都須要進行交換運算。舉個例子來講，一個數列 5 4 3 2 1 進行冒泡升序排列
 * <p>
 * 第一輪的兩兩比較，須要比較4次；獲得 4 3 2 1 5
 * 第二輪的兩兩比較，須要比較3次；獲得 3 2 1 4 5
 * 第三輪的兩兩比較，須要比較2次；獲得 2 1 3 4 5
 * 第四輪的兩兩比較，須要比較1次；獲得 1 2 3 4 5
 * <p>
 * 因此總的比較次數爲 4 + 3 + 2 + 1 = 10次
 * 對於n位的數列則有比較次數爲 (n-1) + (n-2) + ... + 1 = n * (n - 1) / 2，這就獲得了最大的比較次數。
 * 而O(N^2)表示的是複雜度的數量級。舉個例子來講，若是n = 10000，那麼 n(n-1)/2 = (n^2 - n) / 2 = (100000000 - 10000) / 2，相對10^8來講，10000小的能夠忽略不計了，因此總計算次數約爲0.5 * N^2。用O(N^2)就表示了其數量級（忽略前面係數0.5）。
 * <p>
 * 綜上所述，冒泡排序的時間複雜度爲：O(n²)
 */
public class MaopaoSort {

    private static int[] array = {1, 2, 0, 3, 5, 4};

    private static void maopaoSort(int[] a) {
        //外層循環，是須要進行比較的輪數，一共進行5次便可
        for (int i = 0; i < a.length - 1; i++) {
            boolean flag = false;
            //內存循環，是每一輪中進行的兩兩比較
            for (int j = 0; j < a.length - i - 1; j++) {
                if (a[j] > a[j + 1]) {
                    int temp = a[j];
                    a[j] = a[j + 1];
                    a[j + 1] = temp;
                    flag = true;
                }
            }
            System.out.println("第" + (i + 1) + "輪排序後的數組爲: " + Arrays.toString(a));
            if (!flag) {
                System.out.println("本輪中的兩兩比較未發生元素互換，排序已經完成啦");
                return;
            }
        }
    }

    public static void main(String[] args) {
        maopaoSort(array);
    }
}