冒泡排序算法【Java版本】

冒泡排序算法

描述：比較相鄰兩個元素大小，如果反序，則交換。如按照升序排序，每趟將數據序列中的最大元素交換到最後的位置，就像氣泡從水裏冒出一樣。

冒泡排序算法實現如下，兩重循環，外層for循環控制最多n-1趟掃描，內層for循環進行一趟

上代碼

 

public class BubblingDemo {


    /**
     * 交換數組中 i 和 j 的位置
     *
     * @param keys
     * @param i
     * @param j
     */
    public static void exchangeElement(int[] keys, int i, int j) {
        int temps = keys[i];
        keys[i] = keys[j];
        keys[j] = temps;
    }


    /**
     * 冒泡排序核心算法
     *
     * @param ori
     * @param asc true:升序  false： 逆序
     * @return
     */
    public static int[] bubbingSort(int[] ori, boolean asc) {
        boolean exchange = true;
        for (int i = 1; i < ori.length && exchange; i++) {
            exchange = false;
            for (int j = 0; j < ori.length - 1; j++) {

                boolean resutl = asc ? ori[j] > ori[j + 1] : ori[j] < ori[j + 1];
                if (resutl) {
                    exchangeElement(ori, j, j + 1);
                    exchange = true;
                }
            }
        }

        return ori;
    }

    public static void main(String[] args) {
        int[] test = new int[]{2, 6, 9, 7, 1};
        int[] targetArr = bubbingSort(test, false);
        System.out.println(Arrays.toString(targetArr));
    }

}

運行上面主函數

 

冒泡排序算法分析

1.最好的情況，數據序列排列，只需一趟掃描，比較n次，沒有數據移動，時間複雜度爲O(n)。

2.最壞情況，數據序列隨機排列和反序排列，需要n-1趟掃描，比較次數和移動次數都是O(n^2),時間複雜度爲O(n^2).