选择排序

基本思路：

有一个待排序的列表，遍历该列表，找出列表中最小的值，与该列表的第一个值交换；然后遍历剩余待排序的列表，找出最小值，与该列表的第二个值交换，以此类推，直到待排序列表的长度为0。

基本代码：

排序接口：

/**
 * 排序接口
 */
public interface Sort {
    /**
     * 数组排序
     *
     * @param arr
     * @return
     */
    int[] arraySort(int[] arr);
}

选择排序类实现排序接口：

/**
 * 选择排序
 */
public class SelectionSort implements Sort {
    @Override
    public int[] arraySort(int[] arr) {
        for (int i = 0; i < arr.length; i++) {
            // 记录最小值的下标
            int minIndex = i;
            // 遍历待排序数组，找出最小值的下标
            for (int j = i + 1; j < arr.length; j++) {
                if (arr[minIndex] > arr[j]) {
                    minIndex = j;
                }
            }
            // 交换数组中的两个值
            int temp = arr[i];
            arr[i] = arr[minIndex];
            arr[minIndex] = temp;
        }
        return arr;
    }
}

排序测试需要的工具类：

/**
 * 排序测试的工具类
 */
public class SortTestHelper {

    public static Sort sort;

    /**
     * 生成有n个元素的随机数组，每个元素的随机范围是[rangeL,rangeR]
     * 如果rangeL大于rangeR，交换两个的值
     */
    public static int[] generateRandomArray(int n, int rangeL, int rangeR) {
        if (rangeL > rangeR) {
            int temp = rangeL;
            rangeL = rangeR;
            rangeR = temp;
        }
        int[] arr = new int[n];
        Random random = new Random();
        for (int i = 0; i < n; i++) {
            arr[i] = random.nextInt(rangeR - rangeL + 1) + rangeL;
        }
        return arr;
    }

    /**
     * 打印数组
     *
     * @param arr
     */
    public static void printArray(int[] arr) {
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + " ");
        }
        System.out.println();
    }

    /**
     * 测试排序的性能
     *
     * @param sortName
     * @param arr
     */
    public static void testSort(String sortName, int[] arr) {
        long startTime = System.currentTimeMillis();
        // 执行排序方法
        sort.arraySort(arr);
        long endTime = System.currentTimeMillis();
        boolean sorted = isSorted(arr);
        System.out.println(sortName + " : " + (double) (endTime - startTime) / 1000 + "\n是否已经排序: " + sorted);
    }

    /**
     * 判断数组是否是有序的
     *
     * @param arr
     * @return
     */
    public static boolean isSorted(int[] arr) {
        for (int i = 0; i < arr.length - 1; i++) {
            if (arr[i] > arr[i + 1]) {
                return false;
            }
        }
        return true;
    }
}

main函数：

public static void main(String[] args) {
        int n = 20;
        // 生成随机数组
        int[] arr = SortTestHelper.generateRandomArray(n, 0, n);
        // 打印待排序数组
        SortTestHelper.printArray(arr);
        SortTestHelper.sort = new SelectionSort();
        // 进行排序，并进行排序分析
        SortTestHelper.testSort("selection sort", arr);
        // 打印已排好序的数组
        SortTestHelper.printArray(arr);
}

执行结果：

19 19 20 17 3 16 6 6 12 10 15 11 19 5 8 13 11 18 7 2 
selection sort : 0.0
是否已经排序: true
2 3 5 6 6 7 8 10 11 11 12 13 15 16 17 18 19 19 19 20