算法基本排序之冒泡排序

提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档

---

简单排序

1.Comparable接口

排序就是在元素之间做比较，而Java提供了一个接口Comparable就是用来定义排序规则的

首先在实体类中实现该接口，并实现compareTo方法：

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

    public int getAge() {
        return age;
    }

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

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

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

    @Override
    public int compareTo(Student student) {
        return this.age-student.age;
    }
}

然后 在测试类中测试：

public class Test {
    public static void main(String[] args) {
        Student s1 = new Student();
        s1.setName("张三");
        s1.setAge(1);
        Student s2 = new Student();
        s1.setName("李四");
        s1.setAge(2);
        Comparable max = getMax(s1, s2);
        System.out.println(max);
    }


    public static Comparable getMax(Comparable c1,Comparable c2) {
        int result = c1.compareTo(c2);
        if (result >= 0 ) {
            return c1;
        }else {
            return c2;
        }
    }
}

返回结果为李四的信息

冒泡排序

排序原理

1.比较相邻的元素，如果前一个元素比后一个元素大，就交换这两个元素的位置

2.对每一对相邻元素做相同的工作，从开始第一对元素到结尾的最后一对元素，最终最后位置的元素就是最大值。

分析实现：

1.外层循环用来控制，是第几次的遍历排序

2.内层循环用来控制这次遍历比较几遍，且是否进行交换

实现如下：

public class Bubble {

public static void main(String[] args) {
    int  a[] = {5,7,8,6,2,3};
    for (int i = 0; i < a.length-1; i++) {
        System.out.println("第"+i+"遍");
        for (int j = 0; j < a.length-i-1; j++) {
            if (a[j] > a[j+1] ) {
                int t = a[j];
                a[j] = a[j+1];
                a[j+1] = t;
            }
        }
    }
    System.out.println(Arrays.toString(a));
}
}

时间复杂度分析

最坏情况：元素正好都是从大到小

比较次数是：从0加到n-1,所以总的执行次数是N^{2-n,即时间复杂度为O（N}2）,所以这类排序方式适用于待排序元素较少的情况

最好情况：元素是从小到大排序 O（1）