算法数据结构：冒泡排序

1、介绍

冒泡排序（Bubble Sort）算法，只会操作相邻的两个数据。每次冒泡操作都会对相邻的两个元素进行比较，看是否满足大小关系要求，如果不满足就让它俩互换。一次冒泡会让至少一个元素移动到它应该在的位置，重复 n 次，就完成了 n 个数据的排序工作。

2、分析

在arr[0～N-1]范围上：

1. arr[0]和arr[1]，谁大谁来到1位置；arr[1]和arr[2]，谁大谁来到2位置…arr[N-2]和arr[N-1]，谁大谁来到N-1位置
2. 在arr[0～N-2]范围上，重复上面的过程，但最后一步是arr[N-3]和arr[N-2]，谁大谁来到N-2位置
3. 在arr[0～N-3]范围上，重复上面的过程，但最后一步是arr[N-4]和arr[N-3]，谁大谁来到N-3位置

…

1. 最后在arr[0～1]范围上，重复上面的过程，但最后一步是arr[0]和arr[1]，谁大谁来到1位置

很明显，如果arr长度为N，每一步常数操作的数量，依然如等差数列一般，所以 $总的常数操作数量 = a*(N^2) + b*N + c$ 其中，a、b、c 都是常数，所以冒泡排序的时间复杂度为 $O(N^2)$。

3、代码实现

3.1、冒泡排序代码

/**
 * @description: 冒泡排序
 * @author: erlang
 * @since: 2020-08-29 19:06
 */
public class BubbleSort {

    public static void bubbleSort(int[] arr) {
        if (arr == null || arr.length < 2) {
            return;
        }

        for (int i = arr.length - 1; i > 0; i--) {
            for (int j = 0; j < i; j++) {
                if (arr[j] > arr[j + 1]) {
                    swap(arr, j, j + 1);
                }
            }
        }
    }

    private static void swap(int[] arr, int i, int j) {
        arr[i] = arr[i] ^ arr[j];
        arr[j] = arr[i] ^ arr[j];
        arr[i] = arr[i] ^ arr[j];
    }

    public static void main(String[] args) {
        ArraySortUtils.testSort(BubbleSort::bubbleSort, 10, 100);
    }
}

3.2、测试工具类

import java.util.Arrays;
import java.util.function.Consumer;

/**
 * @description: 数组排序工具
 * @author: erlang
 * @since: 2020-08-29 10:49
 */
public class ArraySortUtils {

    /**
     * 随机生成待测试的数组
     *
     * @param maxSize  数组最大长度
     * @param maxValue 数组中最大的值
     * @return 返回生成的数组
     */
    public static int[] generateRandomArray(int maxSize, int maxValue) {
        int[] arr = new int[(int) ((maxSize + 1) * Math.random())];
        for (int i = 0; i < arr.length; i++) {
            arr[i] = (int) ((maxValue + 1) * Math.random()) - (int) (maxValue * Math.random());
        }
        return arr;
    }

    /**
     * 输出数组的元素
     *
     * @param arr 数组
     */
    public static void printArray(int[] arr) {
        System.out.println("");
        System.out.println("+++++++++++++++++++++++++++++++++++++++++++++++++++START");
        for (int value : arr) {
            System.out.print(value + " ");
        }
        System.out.println("");
        System.out.println("+++++++++++++++++++++++++++++++++++++++++++++++++++END");
    }

    public static void comparator(int[] arr) {
        Arrays.sort(arr);
    }

    /**
     * 重新复制一个新数组
     *
     * @param arr 待复制的数组
     * @return 返回复制的新数组
     */
    public static int[] copyArray(int[] arr) {
        if (arr == null) {
            return null;
        }
        int[] res = new int[arr.length];
        System.arraycopy(arr, 0, res, 0, arr.length);
        return res;
    }

    /**
     * 比较两个数组的元素是否相等
     *
     * @param arr1 待比较的数组 1
     * @param arr2 待比较的数组 2
     * @return 返回校验结果 true/false
     */
    public static boolean isEqual(int[] arr1, int[] arr2) {
        if (arr1 == null && arr2 == null) {
            return true;
        }
        if (arr1 == null || arr2 == null) {
            return false;
        }
        if (arr1.length != arr2.length) {
            return false;
        }
        for (int i = 0; i < arr1.length; i++) {
            if (arr1[i] != arr2[i]) {
                return false;
            }
        }
        return true;
    }

    /**
     * 测试排序方法的排序结果是否正确
     *
     * @param consumer 回调用户自定义的排序方法
     * @param maxSize  数组最大长度
     * @param maxValue 数组中最大的数，即 0 - maxValue
     */
    public static void testSort(Consumer<int[]> consumer, int maxSize, int maxValue) {
        int testTime = 5000;
        boolean succeed = true;
        for (int i = 0; i < testTime; i++) {
            // 生成新数组
            int[] arr1 = ArraySortUtils.generateRandomArray(maxSize, maxValue);
            // 复制新数组
            int[] arr2 = copyArray(arr1);
            // 回调用户自定义的排序方法，对 arri1 排序
            consumer.accept(arr1);
            // 使用系统自带的排序方法，对 arr2 排序
            comparator(arr2);
            // 比较两种处理结果是否一致
            if (!isEqual(arr1, arr2)) {
                succeed = false;
                printArray(arr1);
                printArray(arr2);
                break;
            }
        }
        // 输出测试结果
        System.out.println(succeed ? "Nice!" : "Error!");
    }
}