算法与数据结构——选择排序

1、选择排序—基本类型

    public static void selectSort(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;
                }
            }
            swap(arr,i,minIndex); // 一轮结束后将最小值替换
        }
    }

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

2、选择排序—泛型

泛型中比较两个数的大小：1、需要实现 Comparable<E> 接口

                                           2、泛型不能定义成基本数据类型

public static <E extends Comparable<E>> void selectSort(E[] arr){
        for(int i=0;i < arr.length;i++){
            int minIndex = i;// 定义每轮中最小值的下标
            for (int j = i+1; j < arr.length; j++) {
                if(arr[minIndex].compareTo(arr[j]) > 0 ){
                    minIndex = j;
                }
            }
            swap(arr,i,minIndex);// 将每轮中最小值进行替换
        }
    }

    private static <E> void swap(E[] arr, int i, int minIndex) {
        E temp = arr[i];
        arr[i] = arr[minIndex];
        arr[minIndex] = temp;
    }

3、选择排序—自定义排序

// 自定义类
public class Person implements Comparable<Person>{
    
    private String name;
    
    private int age;

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

    @Override
    public int compareTo(Person another) {
        return this.age - another.age;
    }

    @Override
    public String toString() {
        return String.format("Person[name:%s,age:%d]",name,age);
    }
}
// 调用第二项上面泛型方法
public static void main(String[] args) {
     Person[] persons = {new Person("Tom",80),
                         new Person("Jack",60),
                         new Person("Jerry",100)};
     selectSort(persons);
     for(Person person:persons){
         System.out.print(person + " ");
     }
}

选择排序：时间复杂度  O(n*n)

一共执行了 1 + 2 + 3 + 4 .... + n-1 次， =   +  ，去掉常数项，取高阶，所以选择排序的时间复杂度为 O(n^2)