选择排序算法

所谓的选择排序算法，就是在待排序的数组中不断的去查找最小值的过程；

首先，我们在待排序的数组中查找一个最小值，这个最小值要满足数组中的其他元素都要比它大，将查找到的这个最小值暂存到一个新的数组中；

然后，再查找剩余数组中最小的一个值，不断的重复查询最小值，指定数组中没有值可查为止，将以此查询到的最小值存入到新的数组中，我们就得到了一个有序的数组。

在开发中为了避免空间的浪费，我们不会new一个新数组，而是在原来的数组上实现上述步骤；

实例代码：

准备一个数组生成器：

public class ArrayGenerator {

    private ArrayGenerator(){}

    public static Integer[] generateOrderedArray(int n){
        Integer[] arr = new Integer[n];
        for(int i=0; i < n; i++) {
            arr[i] = i;
        }
            return arr;
    }
    // 生成一个长度为n的随机数组，每个数字的范围是[0，bound)
    public static Integer[] generateEandomArray(int n,int bound){
        Integer[] arr = new Integer[n];
        Random rnd = new Random();
        for(int i=0; i<n; i++){
            arr[i] = rnd.nextInt(bound);
        }
        return arr;
    }
}

排序辅助类

public class SortingHelper {

    private SortingHelper(){}
    //用以验证排序后的数组是否是有序数组
    public static <E extends Comparable> boolean isSorted(E[] arr){
        for(int i = 1;i<arr.length; i++){
            if(arr[i - 1].compareTo(arr[i])>0){
                return false;
            }
        }
        return true;
    }

    //验证算法的时效性
    public static <E extends Comparable> void sortTest(String sortName,E[] arr){
        Long startTime = System.nanoTime();
        if(sortName.equals("SelectionSort")){
            ChoiceTest.genericSort(arr);
        }
        Long endTime = System.nanoTime();
        double time = (endTime - startTime) / 1000000000.0;
        if(!SortingHelper.isSorted(arr)){
            throw new RuntimeException(sortName+" failed!");
        }
        System.out.println(String.format("%s , n = %d : %f s",sortName, arr.length,time));
    }
}

创建一个实体类：

public class Student implements Comparable<Student>{

    private String name;
    private int score;

    public Student(String name, int score){
        this.name = name;
        this.score = score;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Student student = (Student) o;
        return Objects.equals(name, student.name);
    }

    @Override
    public int compareTo(Student another) {
        /*
        if(this.score == another.score)
            return -1;
        else if(this.score == another.score)
            return 0;
        return 1;
        */
        //推荐写法，效果与注释的相同
        return this.score - another.score;
    }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", score=" + score +
                '}';
    }
}

测试类：

/*
* 选择排序
* 选择排序算法是一个不断从数组中找到当中的最小值的过程，首先，在待排序的数组中找到一个最小值，
* 这个最小值要满足一下比数组中其他所有元素都要小，然后再找剩余元素的最小值的，不断的重复查找最小值直到最后一个，
* 这样我们就能得到一个排序好的值。
* */
public class ChoiceTest {

    private ChoiceTest(){}
    //arr[0...i)是有序的；arr{i...n)是无序的——循环不变量
    public static void main(String[] args) {
        /*
        int[] arr = {23,76,12,90,4,2,1};
        sort(arr);
        System.out.println(Arrays.toString(arr));
        */
        int n = 10000;
        //Integer[] arr = {23,76,12,90,4,2,1};
        Integer[] arr = ArrayGenerator.generateEandomArray(n,n);
        Long startTime = System.nanoTime();
        genericSort(arr);
        Long endTime = System.nanoTime();
        double time = (endTime - startTime) / 1000000000.0;

        if(!SortingHelper.isSorted(arr)){
            throw new RuntimeException("SortingHelper failed!");
        }

        System.out.println("Time："+time);
        //System.out.println(Arrays.toString(arr));

        SortingHelper.sortTest("SelectionSort",arr);
        /*
        Student[] students = {new Student("Alice",98),
                new Student("Bobo",100),
                new Student("Charles",66)};
        ChoiceTest.genericSort(students);
        for(Student student:students){
            System.out.println(student.toString());
        }
        */
    }
    /**
     * 泛型排序方法
     * 让E这种类型实现Comparable接口的，针对泛型语法来说要使用extend来进行约束
     * 在泛型中它表示的不是继承，而是表示实现某一个接口。
     * 实现了这个接口代表的这个类是可比较的
     */
    public static <E extends Comparable<E>> void genericSort(E[] arr){
        for(int i = 0;i < arr.length; i++){
            // 选择 arr[i...n) 中的最小的索引
            int minIndex = i;
            for(int j = i; j < arr.length;j++){
                if(arr[j].compareTo(arr[minIndex]) < 0){
                    minIndex = j;
                }
            }
            genericSwap(arr,i,minIndex);
        }
    }
    //普通排序方法
    public static void sort(int[] arr){
        for(int i = 0;i < arr.length; i++){
            // 选择 arr[i...n) 中的最小的索引
            int minIndex = i;
            for(int j = i; j < arr.length;j++){
                if(arr[j] < arr[minIndex]){
                    minIndex = j;
                }
            }
            swap(arr,i,minIndex);
        }
    }
    //普通方法
    private static void swap(int[] arr, int i, int j){
        int tmp = arr[i];
        arr[i] = arr[j];
        arr[j] = tmp;
    }
    //泛型方法
    private static <E> void genericSwap(E[] arr, int i, int j){
        E tmp = arr[i];
        arr[i] = arr[j];
        arr[j] = tmp;
    }
}

选着排序算法，有两层for循环，假设它的数据体量为n，算法的准确复杂度应该为：（1+n）*n/2，约掉不重要的常数，它的算法复杂度应该为：O（）。