数据结构和算法-实现带约束泛型的选择排序法

1 选择排序的实现思路

选择排序法的实现思路如下：

先把最小的拿出来
剩下的，再把最小的拿出来
剩下的，再把最小的拿出来
…
每次选择还没处理的元素里最小的元素

---

2 实现选择排序法

public class SelectionSort {
    private SelectionSort(){}
    public static void sort(int[] arr){
        // arr[0...i) 是有序的；arr[i...n) 是无序的
        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 t = arr[i];
        arr[i] = arr[j];
        arr[j] = t;
    }
    public static void main(String[] args){
        int[] arr = {1, 4, 2, 3, 6, 5};
        SelectionSort.sort(arr);
        for(int e: arr)
            System.out.print(e + " ");
        System.out.println();
    }
}

---

3 使用带约束的泛型

上面的选择排序只能对整型进行排序，可以使用 Comparable 接口实现任意对象的比较

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 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;
//        return another.score - this.score;
    }
    @Override
    public boolean equals(Object student){
        if(this == student)
            return true;
        if(student == null)
            return false;
        if(this.getClass() != student.getClass())
            return false;
        Student another = (Student)student;
        return this.score == another.score;
    }
    @Override
    public String toString(){
        return String.format("Student(name: %s, score: %d)", name, score);
    }
}

public class SelectionSort {
    private SelectionSort(){}
    public static <E extends Comparable<E>> void sort(E[] arr){
        // arr[0...i) 是有序的；arr[i...n) 是无序的
        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;
            }
            swap(arr, i, minIndex);
        }
    }
    private static <E> void swap(E[] arr, int i, int j){
        E t = arr[i];
        arr[i] = arr[j];
        arr[j] = t;
    }
    public static void main(String[] args){
        Integer[] arr = {1, 4, 2, 3, 6, 5};
        SelectionSort.sort(arr);
        for(int e: arr)
            System.out.print(e + " ");
        System.out.println();
        Student[] students = {new Student("Alice", 98),
                              new Student("Bobo", 100),
                              new Student("Charles", 66)};
        SelectionSort.sort(students);
        for(Student student: students)
            System.out.print(student + " ");
        System.out.println();
    }
}

---

4 选择排序法的复杂度分析

4.1 数组生成器

用于生成有序数组和随机数组

import java.util.Random;
public class ArrayGenerator {
    private ArrayGenerator() {
    }
     // 生成一个长度为 n 的有序数组
    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[] generateRandomArray(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;
    }

4.2 判断数组是否有序

isSorted用于判断数组是否有序
sortTest用于打印排序开始到完成使用的时间

public class SortingHelper {

    private SortingHelper(){}

    public static <E extends Comparable<E>> 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<E>> void sortTest(String sortname, E[] arr){

        long startTime = System.nanoTime();
        if(sortname.equals("SelectionSort"))
            SelectionSort.sort(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 SelectionSort {
    private SelectionSort() {
    }
    public static <E extends Comparable> void sort(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;
            }
            swap(arr, i, minIndex);
        }
    }

    private static <E> void swap(E[] arr, int i, int j) {
        E t = arr[i];
        arr[i] = arr[j];
        arr[j] = t;
    }
    public static void main(String[] args) {
        int[] dataSize = {10000, 100000};
        for (int n : dataSize) {
            Integer[] arr = ArrayGenerator.generateRandomArray(n, n);
            SortingHelper.sortTest("SelectionSort", arr);
        }
    }
}

从输出结果中可以看出，数据量相差了10倍，选择排序的运行时间相差了100倍，这也很好的说明了选择排序是O(n^2)时间复杂度的排序算法。

---

5 换个角度实现选择排序法

实现一个sort2 方法，sort2 的基本逻辑是，从后向前扫描，对于每一个 i，寻找 arr[0...i] 区间中的最大值，记这个最大值的索引是 maxIndex，然后，只需要每次将 arr[i] 和 arr[maxIndex] 交换位置即可。

也就是在 sort 中，我们从前向后，每次找后面未排序部分的最小值，和 arr[i] 交换；
在 sort2 中，我们从后向前，每次找前面未排序部分的最大值，和 arr[i] 交换。

public class SelectionSort {

    private SelectionSort(){}

    public static <E extends Comparable> void sort(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;
            }

            swap(arr, i, minIndex);
        }
    }

    // 换个方法实现选择排序法，我们叫 sort2
    public static <E extends Comparable> void sort2(E[] arr){

        for(int i = arr.length - 1; i >= 0; i --){

            // 选择 arr[0...i] 中的最大值
            int maxIndex = i;
            for(int j = i; j >= 0; j --){
                if(arr[j].compareTo(arr[maxIndex]) > 0)
                    maxIndex = j;
            }

            swap(arr, i, maxIndex);
        }
    }

    private static <E> void swap(E[] arr, int i, int j){

        E t = arr[i];
        arr[i] = arr[j];
        arr[j] = t;
    }

    public static void main(String[] args){

        int[] dataSize = {10000, 100000};
        for(int n: dataSize){
            Integer[] arr = ArrayGenerator.generateRandomArray(n, n);
            SortingHelper.sortTest("SelectionSort2", arr);
        }
    }
}

在SortingHelper的sortTest方法中添加一个条件