排序算法(插入、冒泡、选择排序)

插入排序

对整数数组 int[] arr 进行插入排序
0~0位置有序
0~1位置有序：盯住1位置往前看，前面数大，则交换，继续往前看…
0~2位置有序：盯住2位置往前看，前面数大，则交换，继续往前看…
…
0~n-1位置有序：盯住n-1位置往前看，前面数大，则交换，继续往前看…

    public static int[] insertSorted(int[] arr){
        //元素少于2个就不用排序了
        if(arr == null || arr.length < 2){
            return arr;
        }
        for (int i = 1; i < arr.length; i++) {
            for (int j = i; j > 0 ; j--) {
                //盯住i位置往前看，前面数大，则交换，继续往前看...
                if(arr[j] < arr[j-1]){
                    CommonUtils.swap(arr,j-1,j);
                }else{//如果发现arr[j] >= arr[j-1]，就不需要继续往前看了，因为前面已经是有序了
                    break;
                }
            }
        }
        return arr;
    }

冒泡排序

对整数数组 int[] arr 进行插入排序
从0~n-1位置遍历，两个两个比较，谁大，谁交换到后面
从1~n-1位置遍历，两个两个比较，谁大，谁交换到后面
从2~n-1位置遍历，两个两个比较，谁大，谁交换到后面
…
从n-2~n-1位置遍历，两个两个比较，谁大，谁交换到后面

    public static int[] pop(int[] arr){
        //元素少于2个就不用排序了
        if(arr == null || arr.length < 2){
            return arr;
        }
        for (int i = 0; i < arr.length; i++) {
            for (int j = i+1; j < arr.length; j++) {
                if(arr[j] < arr[j-1]){
                    CommonUtils.swap(arr,j-1,j);
                }
            }
        }
        return arr;
    }

选择排序

从0~n-1位置遍历，选择最小值与0位置元素交换
从1~n-1位置遍历，选择最小值与1位置元素交换
从2~n-1位置遍历，选择最小值与2位置元素交换
…

    public static int[] selectSorted(int[] arr){
        if(arr == null || arr.length < 2){
            return arr;
        }
        for (int i = 0; i < arr.length; i++) {
            int minIndex = i;
            //找出最小元素
            for (int j = i; j < arr.length; j++) {
                if(arr[j] < arr[minIndex]){
                    minIndex = j;
                }
            }
            //最小元素与i元素交换
            CommonUtils.swap(arr,i,minIndex);
        }
        return arr;
    }

对数器

手写对数器，校验算法的正确性

    /**
     * 对数器，校验算法的正确性
     */
    public static void generatorMethod(){
        //数组长度
        int arrLen = 10;
        //数组元素最大值
        int maxMember = 9;
        //测试次数
        int count = 100000;
    A:    for (int i = 0; i < count; i++) {
            //随机生成数组
            int[] arr = generateArray(arrLen,maxMember);
            //复制数组
            int[] arr1 = copyArr(arr);
            int[] arr2 = copyArr(arr);
            //完全没问题的排序算法
            Arrays.sort(arr1);
            //自己写的排序算法，此处为插入排序，可以替换为下选择排序或者冒泡排序
            insertSorted(arr2);
            for (int j = 0; j < arr1.length; j++) {
                CommonUtils.printArray(arr);
                CommonUtils.printArray(arr2);
                if(arr1[j] != arr2[j]){
                    System.out.println("insertSorted。。。排序方法有误");
                    break A;
                }
                System.out.println("----------------------------------------");
            }
        }
        System.out.println("insertSorted。。。排序方法没有问题");
    }

    /**
     * 数组的复制，生成新的数组对象
     * @param arr
     * @return
     */
    private static int[] copyArr(int[] arr) {
        int[] newArr = new int[arr.length];
        for (int i = 0; i < arr.length; i++) {
            newArr[i] = arr[i];
        }
        return newArr;
    }

    /**
     * 随机生成指定条件的整型数组
     * @param arrLen 数组长度
     * @param maxMember 数组元素最大值
     * @return 返回数组对象
     */
    public static int[] generateArray(int arrLen, int maxMember) {
        int[] arr = new int[arrLen];
        for (int i = 0; i < arrLen; i++) {
            //数组的每个元素的取值范围是[-maxMember,maxMember]间的整数
            arr[i] = ((int)(Math.random()*(maxMember+1))) - ((int)(Math.random()*(maxMember+1)));
        }
        return arr;
    }