测试选择排序算法性能

主函数

import helper.SortTestHleper;

public class SelectionSort {

    // 实现泛型排序
    public static <T extends Comparable<? super T>> void selectionSort(T[] a, int n) {
        for (int i = 0; i < n; i++) {
            // 寻找[i,n)区间里的最小值
            int minIndex = i;
            T temp;
            for (int j = i + 1; j < n; j++) {
                if (a[j].compareTo(a[minIndex]) < 0) {
                    minIndex = j;
                }
                temp = a[i];
                a[i] = a[minIndex];
                a[minIndex] = temp;
            }
        }
    }

    public static void main(String[] args) {
        // 泛型时不能采用基本类型
        System.out.println("====整型====");
        int n = 1000;
        Integer[] a = SortTestHleper.generateRandomArray(n, 0, n);
        SortTestHleper.testSort(a,a.length);
        SortTestHleper.printArray(a,a.length);
    }
}

测试用例

import java.util.Random;

import sort.SelectionSort;

public class SortTestHleper {

    // 生成n个元素的随机数组，每个元素的随机范围为[rangeL,rangeR]
    public static Integer[] generateRandomArray(int n, int rangeL, int rangeR) {
        Integer[] arr = new Integer[n];
        Random random = new Random();
        for (int i = 0; i < arr.length; i++) {
            arr[i] = (int) (Math.random() * (rangeR - rangeL + 1)) + rangeL;
        }
        return arr;
    }

    // 打印数组
    public static <T extends Comparable<? super T>> void printArray(T[] arr, int n) {
        for (int i = 0; i < n; i++) {
            System.out.println(arr[i]);
        }
    }

    // 测试排序算法性能
    public static <T extends Comparable<? super T>> void testSort( T[] arr, int n) {
        long start = System.currentTimeMillis();
        SelectionSort.selectionSort(arr, arr.length);
        long end = System.currentTimeMillis();
        assert (isSorted(arr, arr.length));
        System.out.println(end-start+"ms");
    }

    private static <T extends Comparable<? super T>> void sort(T[] arr, int n) {

    }

    // 判断排序正确性
    public static <T extends Comparable<? super T>> boolean isSorted(T[] arr, int n) {
        for (int i = 0; i < n - 1; i++) {
            if (arr[i].compareTo(arr[i + 1]) > 0)
                return false;
        }
        return true;
    }
}

输出结果

-数据为10000时

408ms

-数据为100000时

46438ms

-可以看数据量增加10倍，计算时间增加约100倍，是一个O（n^2）的关系