Java-随机生成算法测试工具类-（二）

排序帮助类-SelectionSort

随机生成数组

生成n个元素的随机array[n]数组，随机元素所在范围为array[rangeL, rangeR]

    /**
     * 生成随机数组
     * @param n 数组个数
     * @param rangeL 随机元素所在左区间
     * @param rangeR 随机元素所在右区间
     * @return
     */
    public static Integer[] generateRandomArray(Integer n, Integer rangeL, Integer rangeR) {
        if (null == n
                || n < 1
                || null == rangeL
                || null == rangeR
                || rangeL >= rangeR) {
            throw new IllegalArgumentException("参数不合法");
        }

        // 生成n个元素的随机数组，每个元素的范围为[rangeL, rangeR]
        Random random = new Random();
        Integer[] array = new Integer[n];
        for(int i = 0; i < n; i++) {
            array[i] = random.nextInt(Integer.MAX_VALUE) % (rangeR - rangeL + 1) + rangeL;
        }
        return array;
    }

生成接见（似乎）有序的随机数组

生成n个元素有序array[n]数组（升序），依据随机进行打乱有序排序。

    /**
     * 生成接见（似乎）有序的随机数组
     * @param n 数组长度
     * @param swapTimes 交换组数
     * @return
     */
    public static Integer[] generateNearlyOrderedArray(Integer n, Integer swapTimes) {
        // 开辟一个空间，遍历n的生成有序随机数组
        Integer[] array = new Integer[n];
        for (int i = 0; i < n; i++) {
            array[i] = i;
        }

        // 交换swapTimes组数据，进行打乱有序排序
        Random random = new Random();
        for (int i = 0; i < swapTimes; i++) {
            // 随机数求余，生成两个在n范围之内的下标
            int posx = random.nextInt(Integer.MAX_VALUE) % n;
            int posy = random.nextInt(Integer.MAX_VALUE) % n;
            // 替换
            swap(array, posx, posy);
        }
        return array;
    }

测试排序的时间周期方法

采用函数式编程之Consumer进行设计方法，将函数作为参数传递的方式进行测试。

    /**
     * 测试排序的时间周期
     * @param sortName 测试算法的名称
     * @param sort 算法的函数
     * @param array 测试的数组
     * @param <T>
     */
    public static  <T> void testSort(String sortName, Consumer<T[]> sort, T[] array) {
        // 纳秒
        long statrTime = System.nanoTime();
        sort.accept(array);
        long endTime = System.nanoTime();
        System.out.println(String.valueOf(endTime - statrTime));
        BigDecimal bigDecimal = new BigDecimal(String.valueOf(endTime - statrTime));
        System.out.println(bigDecimal.doubleValue());
        BigDecimal divide = bigDecimal.divide(new BigDecimal("1000000000"));
        System.out.println(sortName + " : " + divide.doubleValue() + "秒");
    }

验证排序正确性：升序

    /**
     * 验证排序正确性：升序
     * @param array
     * @param <T>
     * @return
     */
    public static <T extends Comparable<T>> boolean isSorted(T[] array) {
        if (null != array) {
            int length = array.length;
            for (int i = 0; i < length - 1; i++) {
                if (array[i].compareTo(array[i + 1]) > 0) {
                    return false;
                }
            }
        }
        return true;
    }

数组值相互替换

    /**
     * 数组值相互替换
     * @param array
     * @param sub1
     * @param sub2
     * @param <T>
     */
    public static <T> void  swap(T array[], Integer sub1, Integer sub2) {
        T temp = array[sub1];
        array[sub1] = array[sub2];
        array[sub2] = temp;
    }

随机生成一个数组进行选择排序

    public static void main(String[] args) {
        // 随机生成一个自定义大小，自定义区间的数组,并且进行排序
        Integer[] randomArray = SortTestHelp.generateRandomArray(1000, 50, 200);
        selectionSort(randomArray);
        System.out.println(Arrays.toString(randomArray));

        // 函数方法
        int n = 10000;
        Integer[] array2 = SortTestHelp.generateRandomArray(n, 0, n);
        SortTestHelp.testSort("测试SortName", SelectionSort::getSort, array2);
        System.out.println(Arrays.toString(array2));
    }

随机生成一个数组进行选择排序结果

此类为工具类，是为了辅助算法进行计算而设计此类，根据后面的算法不断增多，对此类不断封装对应的方法。

链接: 个人博客.GitHub