数据结构之用对数器验证基础排序（冒泡排序、选择排序、插入排序）

刷力扣的时候，经常可以看到会给出题目的数值范围，数组长度范围和数组中数据的取值范围等等，这些信息其实就是让你自己用对数器验证的。
所谓的对数器就是相当于你自己写的随机样本，和一个正确函数比较，如果结果相同，就说明你写的含数没问题。

对数器使用：
1.生成随机样本，随机样本的参数可以自己设定，一半根据题目要求（testTime：生成随机样本的数量，越多越准确；size：数组长度范围；value：数值范围）
2.写一个正确函数，所谓正确函数，就是保证一定正确的函数，不用考虑时间复杂度。如果Java有内置函数最好，比如Java内置的排序。
3.复制随机样本，一份在你自己写的函数中跑，一份在正确函数中跑。
4.对比结果，如果你自己写的函数跑出来的结果和正确函数一样，说明正确。
对数器代码：

public static void duiShuQi(){
        int testTime=5000;
        int size=10;
        int value=1000;
        boolean isok=true;
        for (int i = 0; i < testTime; i++) {
            int[] arr1 = generateRandomArray(size, value);
            int[] arr2=arr1.clone();
            //正确函数
            Arrays.sort(arr1);
            //自己的函数
            insertSort(arr2);
            if(!isEquals(arr1,arr2)){
                System.out.println("Fucking fucked!");
                printArray(arr1,arr2);
                break;
            }
        }
        System.out.println("Nice!");
    }

    //对比结果
    public static boolean isEquals(int[] arr1,int[] arr2){
        if(arr1.length!=arr2.length){
            return false;
        }
        for (int i = 0; i < arr1.length; i++) {
            if(arr1[i]!=arr2[i]){
                return false;
            }
        }
        return true;
    }
    
    //打印错误
    public static void printArray(int[] arr1,int[] arr2){
        for (int i = 0; i < arr1.length; i++) {
            System.out.print(arr1[i]+",");
        }
        System.out.println();
        for (int i = 0; i < arr2.length; i++) {
            System.out.println(arr2[i]+",");
        }
    }

    //测试样本产生器
    public static int[] generateRandomArray(int size, int value){
        int[] arr=new int[(int)((size+1)*Math.random())];
        for (int i = 0; i < arr.length; i++) {
            arr[i]=(int)((value+1)*Math.random())-(int)(value*Math.random());
        }
        return arr;
    }

我自己手写的三个基础排序，已经用对数器验证无误的。
冒泡排序：

public static void bubbleSort(int[] arr){
        if(arr==null||arr.length<2){
            return;
        }
        boolean shaoBing=true;
        for (int i = arr.length-1; i >0 ; i--) {
            for (int j = 0; j < i; j++) {
                if(arr[j]>arr[j+1]){
                    int temp=arr[j];
                    arr[j]=arr[j+1];
                    arr[j+1]=temp;
                    shaoBing=false;
                }
            }
            if(shaoBing){
                return;
            }
        }

选择排序：

public static void selectSort(int[] arr){
        if(arr==null||arr.length<2){
            return;
        }
        for (int i = 0; i < arr.length-1; i++) {
            for (int j = i+1; j < arr.length; j++) {
                if(arr[i]>arr[j]){
                    int temp=arr[i];
                    arr[i]=arr[j];
                    arr[j]=temp;
                }
            }
        }
    }

插入排序：

public static void insertSort(int[] arr){
        if(arr==null||arr.length<2){
            return;
        }
        for (int i = 1; i < arr.length; i++) {
            for (int j = i-1; j >=0 && arr[j]>arr[j+1]; j--) {
                int temp=arr[j];
                arr[j]=arr[j+1];
                arr[j+1]=temp;
            }
        }
    }