2冒泡排序

P11_11_排序_Comparable接口

1、什么是API?

API（Application Programming Interface，应用程序接口）是一些预先定义的函数，而又无需访问原码

2、测试题：

需求：
1.定义一个学生类Student，具有年龄age和姓名username两个属性，并通过Comparable接口提供比较规则；
2.定义测试类Test，在测试类Test中定义测试方法Comparable getMax(Comparable c1,Comparable c2)完成测试

Comparable排序，不单单是对数字进行排序，需要对所有实现Comparable接口的对象，进行排序。
因此我们排序的东西，是Comparable接口的实现类对象。

package cn.itcast.algorithm.sort;
//定义一个学生类Student，具有年龄age和姓名username两个属性，并通过Comparable接口提供比较规则；
public class Student implements Comparable<Student>{
    private String username;//为什么要private？
    private int age;

    //getter and setter的作用是什么？
    /*
    * setter 和 getter 的实现通常并没有什么技术含量，setter用来赋值，getter用来返回值。
    * setter是向一个类中的属性中赋值，getter则是取出该类的某属性的值。
    * */
    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;
    }

    /*
    toString方法会返回一个“以文本方式表示”此对象的字符串。
    结果应是一个简明但易于读懂的信息表达式。建议所有子类都重写此方法。
     */
    @Override
    public String toString() {
        return "Student{" +
                "username='" + username + '\'' +
                ", age=" + age +
                '}';
    }

    //这个是什么干嘛的？
    //定义比较规则。
    @Override
    public int compareTo(Student o) {
        return this.getAge()-o.getAge();
    }
}

package cn.itcast.algorithm.test;

import cn.itcast.algorithm.sort.Student;
//定义测试类Test，在测试类Test中定义测试方法Comparable getMax(Comparable c1,Comparable c2)完成测试
public class TestComparable {
    public static void main(String[] args) {
        Student s1 = new Student();
        //设置姓名
        s1.setUsername("张三");
        s1.setAge(18);
        Student s2 = new Student();
        //设置姓名
        s2.setUsername("李四");
        s2.setAge(20);

        Comparable max = getMax(s1, s2);
        System.out.println(max);
    }

    //定义一个接口方法？？？
    //参数也是接口
    public static Comparable getMax(Comparable c1,Comparable c2){
        int result = c1.compareTo(c2);
        //如果result<0,则c1比c2小;
        //如果result>0，则c1比c2大;
        //如果result==0,则c1和2-样大;
        if(result>=0){
            return c1;
        }else{
            return c2;
        }
    }
}

P12_12_排序_冒泡排序1

1、测试题：

需求：
排序前：{4,5,6,3,2,1}
排序后：{1,2,3,4,5,6}

2、原理：

排序原理：

1. 比较相邻的元素。如果前一个元素比后一个元素大，就交换这两个元素的位置。
2. 对每一对相邻元素做同样的工作，从开始第一对元素到结尾的最后一对元素。最终最后位置的元素就是最大值。

我的理解：

1. 比较相邻的元素。如果前一个元素比后一个元素大，就交换这两个元素的位置。
2. 每一次找到最大的元素，放到最后，直到排序结束。
   

P13_13_排序_冒泡排序2

1、测试题：

需求：
排序前：{4,5,6,3,2,1}
排序后：{1,2,3,4,5,6}

2、冒泡排序API设计:

package cn.itcast.algorithm.sort;

public class Bubble {
    //对数组内的元素进行排序
    public static void sort(Comparable[] a){
        for(int i = a.length-1; i > 0; i--){//循环5次，i>0时，都要循环
            for (int j = 0; j < i; j++) {
                //比较索引处的值
                if(greater(a[j],a[j+1])){
                    exch(a,j,j+1);
                }
            }
        }
    }
    //判断v是否大于w
    private static boolean greater(Comparable v, Comparable w){
        return v.compareTo(w) > 0;
        //大于0说明，v大于w
    }
    //i,j交换位置
    private static void exch(Comparable[] a, int i, int j){
        Comparable temp;//这个是定义了接口变量吗？
        temp = a[i];
        a[i] = a[j];
        a[j] = temp;
    }
}

package cn.itcast.algorithm.test;

import cn.itcast.algorithm.sort.Bubble;

import java.util.Arrays;

public class BubbleTest {
    public static void main(String[] args) {
        //如何写数组？
//    int[] arr = {4,5,6,3,2,1};
//    如果使用这一种定义数组的方法，会报错

//        包装类，已经有Comparable接口了
        Integer[] arr = {4,5,6,3,2,1};
        Bubble.sort(arr);

//        转换成字符串去打印
        System.out.println(Arrays.toString(arr));
    }
}

P14_14_排序_冒泡排序3