排序(一)：选择排序法

一. 基本思想
    选出数组中的最小元素，将它与数组的第一个元素交换位置。再从剩下的元素中选出最小的元素，将它与数组的第二个元素交换位置。不断进行这样的操作，直到将整个数组排序。

二. 代码实现

• 版本一

/**
 * <br>选择排序</br>
 * O(n^2)
 */
public class SelectionSort {

    /**
     * 选择排序思想：
     * 从第一个位置开始，找到后面最小的元素，然后与第一个位置的元素交换，
     * 这样，第一个位置的元素就是最小的元素了；
     * 然后从第二个位置开始，依次重复上面的步骤。
     * 两层for循环：
     * 外层循环：控制比较的轮数
     * 内层循环：寻找剩下元素中的最小元素
     * @param arr
     */
    public static void sort(int[] arr) {
        int n = arr.length;
        int minIndex;
        for (int i = 0; i < n-1; i++) {
            // 寻找[i,n)区间里的最小索引
            minIndex = i;
            for (int j = i + 1; j < n; j++) {
                if (arr[j] < arr[minIndex]){
                    minIndex = j;
                }
            }
            // 将每轮比较的较小值与当前值交换
            if (minIndex != i){
                swap(arr,i,minIndex);
            }
        }
    }

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

    public static void main(String[] args) {
        int N = 20000;
        int[] arr = SortTestHelper.generateRandomArray(N, 1, 100000);
        SortTestHelper.testSort("com.hong.sort.SelectionSort", arr);
    }
}

import com.google.common.primitives.Ints;
import java.lang.reflect.Method;
import java.util.Arrays;
import java.util.List;
import java.util.Random;

/**
 * 排序算法测试辅助类
 */
public class SortTestHelper {

    private SortTestHelper() {
    }

    /**
     * 生成n个元素的随机数组,每个元素的随机范围为[leftRange,rightRange]
     *
     * @param n
     * @param leftRange
     * @param rightRange
     * @return
     */
    public static int[] generateRandomArray(int n, int leftRange, int rightRange) {
        assert leftRange <= rightRange;
        Random random = new Random();
        int[] arr = new int[n];
        for (int i = 0; i < n; i++) {
            arr[i] = leftRange + random.nextInt(rightRange) % (rightRange - leftRange + 1);
        }
        return arr;
    }

    /**
     * 生成一个近乎有序的数组
     *
     * @param n
     * @param swapTimes
     * @return
     */
    public static int[] generateNearlyOrderedArray(int n, int swapTimes) {
        int[] arr = new int[n];
        for (int i = 0; i < n; i++) {
            arr[i] = i;
        }

        Random random = new Random();
        for (int i = 0; i < swapTimes; i++) {
            int posx = random.nextInt(n);
            int posy = random.nextInt(n);
            int t = arr[posx];
            arr[posx] = arr[posy];
            arr[posy] = t;
        }

        return arr;
    }

    /**
     * 打印arr数组的所有内容
     *
     * @param arr
     */
    public static void printArray(Object[] arr) {
        Arrays.asList(arr).forEach(e -> {
            System.out.print(e);
            System.out.print(' ');
        });
        System.out.println("============================");
    }

    /**
     * 判断arr数组是否有序(升序)
     *
     * @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;
    }

    /**
     * 测试sortClassName所对应的排序算法排序arr数组所得到结果的正确性和算法运行时间
     *
     * @param sortClassName
     * @param arr
     */
    public static void testSort(String sortClassName, int[] arr) {
        /**
         * Java的反射机制，通过排序的类名，运行排序函数
         */
        try {
            Class sortClass = Class.forName(sortClassName);
            Method sortMethod = sortClass.getMethod("sort", new Class[]{int[].class});
            Object[] params = new Object[]{arr};

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

            assert isSorted(arr);
            System.out.println(isSorted(arr));
            System.out.println(sortClass.getSimpleName() + " : " + (endTime - startTime) + "ms");
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

• 版本二

/**
 * <br>选择排序算法优化</br>
 * 在每一轮中, 可以同时找到当前未处理元素的最大值和最小值
 */
public class SelectionSort2 {

    public static void sort(int[] arr) {
        int left = 0;
        int right = arr.length - 1;

        int minIndex;
        int maxIndex;
        while (left < right) {
            minIndex = left;
            maxIndex = right;

            if (arr[minIndex] > arr[maxIndex]) {
                swap(arr, minIndex, maxIndex);
            }

            for (int i = left + 1; i < right; i++) {
                if (arr[i] < arr[minIndex]){
                    minIndex = i;
                }else if (arr[i] > arr[maxIndex]){
                    maxIndex = i;
                }
            }

            swap(arr, left, minIndex);
            swap(arr, right, maxIndex);

            left++;
            right--;
        }
    }

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

    public static void main(String[] args) {
        int N = 20000;
        int[] arr = SortTestHelper.generateRandomArray(N, 0, 100000);
        SortTestHelper.testSort("com.hong.sort.SelectionSort2", arr);
    }
}

三. 算法分析
表现最稳定的排序算法之一，因为无论什么数据进去都是O(n^2)的时间复杂度，所以用到它的时候，数据规模越小越好。唯一的好处可能就是不占用额外的内存空间了吧。理论上讲，选择排序可能也是平时排序一般人想到的最多的排序方法了吧。