选择排序法

基础版

public class SelectSort {
    private SelectSort() {
    }

    public static void sort(int[] arr) {
        for (int i = 0; i < arr.length; i++) {
            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 a = arr[i];
        arr[i] = arr[j];
        arr[j] = a;
    }
}

进阶版

• 1 先实现一个自定义Dog类，Dog类实现compareTo方法

public class Dog implements Comparable<Dog> {
    public String name;
    public int age;

    public Dog(String name, int age) {
        this.name = name;
        this.age = age;
    }

    @Override
    public int compareTo(Dog o) {
        return this.age - o.age;
    }

    @Override
    public boolean equals(Object dog) {
        if (this == dog) {
            return true;
        }
        if (dog == null) {
            return false;
        }
        if (this.getClass() != dog.getClass()) {
            return false;
        }
        Dog newDog = (Dog) dog;
        return this.name.equals(newDog.name);
    }

    @Override
    public String toString() {
        return String.format("Dog(name:%s,age:%s)", name, age);
    }
}

• 自定义Dog类进阶版排序

public class SelectSortGenericity {
    private SelectSortGenericity() {
    }

    public static<E extends Comparable<E>> void sort(E[] arr) {
        for (int i = 0; i < arr.length; i++) {
            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 a = arr[i];
        arr[i] = arr[j];
        arr[j] = a;
    }
}

测试性能

public static Integer[] generatorRandomArray(int n,int boundary) {
        Integer[] arr = new Integer[n];
        Random random=new Random();
        for (int i = 0; i < n; i++) {
            arr[i]=random.nextInt(boundary);
        }
        return arr;
}

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 void main(String[] args) {
        double t = 1000000000.0;

        int[] times = {10000, 100000};
        for (int n : times) {
            Integer[] arr = ArrayGenerator.generatorRandomArray(n,n);
            long startTime = System.nanoTime();
            SelectSortGenericity.sort(arr);
            long endTime = System.nanoTime();
            System.out.println((endTime - startTime) / t + "s");

            if (!SortingHelper.isSorted(arr)) {
                throw new RuntimeException("算法有bug");
            }
        }

    }

事实证明两次比较n相差10倍，性能却差了100倍

衷心感谢算法大牛：Liuyubobobo 老师