选择排序+冒泡排序

排序

**Comparable接口：**java提供的用来定义排序规则的接口

/**
 * 定义一个学生类，具有姓名和年龄两个属性，通过Comparable接口提供比较规则
 */
public class Student implements Comparable<Student>{
    private String username;
    private int age;

    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public int compareTo(Student o) {
        return this.getAge()-o.getAge();
    }
}
//测试类
public class TestComparable {
    public static void main(String[] args) {
        //创建两个Student对象，调用getMax完成测试
        Student s1 = new Student();
        Student s2 = new Student();
        s1.setAge(15);
        s1.setUsername("王");
        s2.setAge(20);
        s2.setUsername("张");
        getMax(s1,s2);
    }
    public static Comparable getMax(Comparable c1,Comparable c2){
        int result = c1.compareTo(c2);
        //result>0,则c1比c2大
        if(result>=0) return c1;
        else return c2;
    }
}

冒泡排序

冒泡排序：比较数组中相邻的两个元素，将小数或大数往前移或后移。冒泡排序嵌套两层循环，时间复杂度为O(n^2)，外层表示冒泡的轮数，里层进行依次比较。

将数组从大到小排序

/**
 * 测试冒泡排序
 */
public static int[] sort1(int[] array){
    int temp=0;
    //外层循环，判断要走多少次 length-1防止溢出
    for (int i = 0; i < array.length-1; i++) {
        //-i是因为每次会找出一个最大数
        for (int j = 0; j < array.length-1-i; j++) {
            //如果第二个数比第一个数大则交换位置
            if(array[j+1]>array[j]){
                temp=array[j];
                array[j]=array[j+1];
                array[j+1]=temp;
            }
        }
    }
    return array;
}

如何优化？

定义一个标志位减少没有意义的比较。

public static int[] sort1(int[] array){
    int temp=0;
    //外层循环，判断要走多少次 length-1防止溢出
    for (int i = 0; i < array.length-1; i++) {
        boolean flag = false;
        //-i是因为每次会找出一个最大数
        for (int j = 0; j < array.length-1-i; j++) {
            //如果第一个数比第二个数大则交换顺序
            if(array[j+1]<array[j]){
                temp=array[j];
                array[j]=array[j+1];
                array[j+1]=temp;
                flag = true;
            }
        }
        if (flag==false)
            break;
    }
    return array;
}

选择排序

原理：每一次遍历都选出最小值放或最大值放在合适的位置。

从小到大的排序：找出最小数的索引，将最小数的索引处的值与第一个索引处的值交换

public static int[] sort2(int[] array){
    for (int i = 0; i < array.length-1; i++) {
        //定义一个变量，记录最小元素所在的索引，默认为参与选择的第一个元素所在的位置
        int min=i;
        for (int j = i+1; j < array.length; j++) {
            //比较最小索引的值与j处的值
            if (array[min]>array[j]){
                min=j; //如果索引min处的值大于j处的值，则将最小索引设为j
            }
        }
        //交换最小元素和i索引的值
        int temp;
        temp=array[i];
        array[i]=array[min];
        array[min]=temp;
    }
    return array;
}

选择排序使用双层循环，外层循环完成数据交换，内层循环做数据比较。

数据比较次数：(n-1)+(n-2)+…+2+1=n^2/2-n/2

数据交换次数：n-1

时间复杂度计算：n^{2/2-n/2+（n-1）=n}2/2+n/2-1

时间复杂度为O(n^2)