数据结构与算法分析（Java语言描述）（1）—— 选择排序

伪代码

重复（元素个数-1）次
  把第一个没有排序过的元素设置为最小值
  遍历每个没有排序过的元素
    如果元素 < 现在的最小值
      将此元素设置成为新的最小值
  将最小值和第一个没有排序过的位置交换

SelectionSort(int[] arr){
    int n = arr.length;
    for(int i = 0; i < n; i++){
        int minIndex = i;
        for(int j = i + 1; j < n;j++){
            if(arr[j] < arr[minIndex]){
                minIndex = j;
            }
        swap(arr, i, minIndex);
        }
    }
}

SelectionSort.java

public class SelectionSort {
    // 我们的算法类不允许产生任何实例
    private SelectionSort() {
    }

    public static void sort(Integer[] arr) {

        int n = arr.length;
        for (int i = 0; i < n; i++) {
            // 寻找[i, n)区间里的最小值的索引
            int minIndex = i;
            for (int j = i + 1; j < n; j++) {
                if (arr[j] < arr[minIndex]) {
                    minIndex = j;
                }
            }
            swap(arr, i, minIndex);
        }
    }

    private static void swap(Integer[] arr, int i, int j) {
        int t = arr[i];
        arr[i] = arr[j];
        arr[j] = t;
    }

    // 单元测试
    public static void main(String[] args) {

        Integer[] arr = SortTestHelper.generateRandomArray(100, 20, 1000);
        SelectionSort.sort(arr);
        SortTestHelper.printArray(arr);
    }

}

SortTestHelper.java

public class SortTestHelper {
    // SortTestHelper 不允许产生任何实例
    private SortTestHelper() {
    }

    // 生成有 n 个元素的随机数组,每个元素的随机范围为[rangeL, rangeR]
    public static Integer[] generateRandomArray(int n, int rangeL, int rangeR) {

        Integer[] arr = new Integer[n];

        for (int i = 0; i < n; i++)
            arr[i] = new Integer((int) (Math.random() * (rangeR - rangeL + 1) + rangeL));
        return arr;
    }

    // 打印 arr 数组的所有内容
    public static void printArray(Object arr[]) {

        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i]);
            System.out.print(' ');
        }
        System.out.println();

        return;
    }

    // 判断 arr 数组是否有序（从大到小排列）
    public static boolean isSorted(Integer[] arr) {

        for (int i = 0; i < arr.length - 1; i++) {
            if (arr[i].compareTo(arr[i + 1]) > 0) {
                return false;
            }
        }
        return true;
    }

    // 测试sortClassName所对应的排序算法排序arr数组所得到结果的正确性和算法运行时间
    public static void testSort(String sortClassName, Integer[] arr) {

        // 通过Java的反射机制，通过排序的类名，运行排序函数

        try {
            // 通过sortClassName获得排序函数的Class对象
            Class sortClass = Class.forName(sortClassName);

            // 通过排序函数的Class对象获得排序方法
            Method sortMethod = sortClass.getMethod("sort", new Class[] { Integer[].class });

            // 排序参数只有一个，是可比较数组arr
            Object[] params = new Object[] { arr };

            long startTime = System.currentTimeMillis();
            // 调用排序函数
            sortMethod.invoke(null, params);
            long endTime = System.currentTimeMillis();

            // 检验结果的正确性
            if (isSorted(arr)) {
                System.out.println("排序后的数组为有序数组");
            }

            // 输出测试的排序算法的运行时间
            System.out.println(sortClass.getSimpleName() + " : " + (endTime - startTime) + "ms");

        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    // 单元测试
    public static void main(String[] args) {
        // printArray(generateRandomArray(100, 100, 200));
        //
        // if (isSorted(generateRandomArray(100, 100, 200))) {
        // System.out.println("测试数组有序");
        // }
        // else {
        // System.out.println("测试数组无序");
        // }

        testSort("sort_method.SelectionSort", generateRandomArray(10000, 100, 2000000000));

    }
}