冒泡排序和插入排序

1.冒泡排序

过程描述

过程：
在arr[0～N-1]范围上：
arr[0]和arr[1]，谁大谁来到1位置；arr[1]和arr[2]，谁大谁来到2位置…arr[N-2]和arr[N-1]，谁大谁来到N-1位置

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

冒泡排序主要方法

  /**
     * 冒泡排序
     *
     * @param arr
     */
    public static void bubbleSort(int[] arr) {
        //判断，如果数组为空，或者数组中只有一个数据，则返回
        if (arr == null || arr.length == 1) {
            return;
        }
        //0 - N-1
        //0 - N-2
        //.....
        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);
                }
            }
        }
    }

测试方法
使用对数器的方式：需要了解对数器概念请看我上一篇：https://blog.csdn.net/sinat_36759535/article/details/108035314

 public static void main(String[] args) {
        //测试50万次
        int testTimes = 50_0000;
        for (int i = 0; i < testTimes; i++) {
            //生成随机数组
            int[] ints = generateArray(8, 10);
            //调用自己写的冒泡排序
            bubbleSort(ints);
            //拷贝一份新数据
            int[] clone = ints.clone();
            //使用jdk自带的排序方法
            Arrays.sort(clone);
            //判断自己写的冒泡排序是否正确
            for (int j = 0; j < ints.length; j++) {
                if (ints[j] != clone[j]) {
                    System.out.println("失败。。。。。。。。。。。。。。");
                }
            }
        }
    }

其他代码

/**
     * 生产随机数组
     *
     * @param maxSize
     * @param maxValue
     * @return
     */
    public static int[] generateArray(int maxSize, int maxValue) {
        //Math.random()  [0,1)
        //N*Math.random() [0,N)
        //我们为了获取一个数组长度在[0,maxSize]，则需要(maxSize + 1) * Math.random()
        int[] arr = new int[(int) ((maxSize + 1) * Math.random())];
        for (int i = 0; i < arr.length; i++) {
            //为获取一个-maxValue ~ +maxValue  则maxValue 需要加1
            arr[i] = (int) (Math.random() * (maxValue + 1)) - (int) (Math.random() * (maxValue + 1));
        }
        return arr;
    }

/**
     * 数组下标值交换
     *
     * @param arr
     * @param i
     * @param j
     */
    private static void swap(int[] arr, int i, int j) {
        int temp = arr[i];
        arr[i] = arr[j];
        arr[j] = temp;
    }

测试结果如下：样本数量50万

2.插入排序

描述过程

想让arr[0~0]上有序，这个范围只有一个数，当然是有序的。
想让arr[0~1]上有序，所以从arr[1]开始往前看，如果arr[1]<arr[0]，就交换。否则什么也不做。
…
想让arr[0~i]上有序，所以从arr[i]开始往前看，arr[i]这个数不停向左移动，一直移动到左边的数字不再比自己大，停止移动。
最后一步，想让arr[0~N-1]上有序， arr[N-1]这个数不停向左移动，一直移动到左边的数字不再比自己大，停止移动。

插入排序主要代码如下：

/**
     * 插入排序
     *
     * @param arr
     */
    public static void insertSort(int[] arr) {
        //数组为空，或者数组长度为1 则返回
        if (arr == null || arr.length == 1) {
            return;
        }
        // 0~0 有序的
        // 0~i 想有序
        for (int i = 0; i < arr.length; i++) {
            for (int j = i - 1; j >= 0 && arr[j] > arr[j + 1]; j--) {
                swap(arr, j, j + 1);
            }
        }
    }

测试：

 public static void main(String[] args) {
        //测试50万次
        int testTimes = 50_0000;
        for (int i = 0; i < testTimes; i++) {
            //生成随机数组
            int[] ints = generateArray(8, 10);
            //调用自己写的冒泡排序
            insertSort(ints);
            //拷贝一份新数据
            int[] clone = ints.clone();
            //使用jdk自带的排序方法
            Arrays.sort(clone);
            //判断自己写的冒泡排序是否正确
            for (int j = 0; j < ints.length; j++) {
                if (ints[j] != clone[j]) {
                    System.out.println("失败。。。。。。。。。。。。。。");
                }
            }
        }
    }

结果如下：
结果ok

插入排序的复杂度我们算为O(N^2)，但其实如果数据是排好序的话，那么插入排序的复杂度就好很多，但是我们算复杂度要用最差的情况来估计。