冒泡排序算法【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).