Java中的二叉树

TreeSet集合是基于TreeMap的实现，而TreeMap是基于二叉树（红黑树）结构，也就是说TreeSet集合的底层使用的二叉树结构。

树结构：是数据结构的一种，在计算机领域中树结构指的是倒立的树。

树结构存储的数据，每个数据需要节点来保存。

二叉树：每个节点下面最多只能有2个子节点。

说明：最多表示一个节点下面可以有两个子节点或者一个子节点或者没有子节点。

在二叉树的根节点（第一个元素），左侧的节点称为左子树，右侧称为右子树。

二叉树存储流程：

1.当存储一个元素的时候，如果是树的第一个元素，这个元素就作为根节点。

2.如果不是第一个元素，那么就拿要存储的元素与根节点进行比较大小

3.大于根元素，就要将存储的元素放到根节点的右侧，作为右叶子节点

4.等于根元素：丢弃

5.小于根元素：就要将存储的元素放到根节点的左侧，作为左叶子节点

6.输出排序：按照层次（从最底层开始）从左往右输入树中结点的值

案例：

​ 使用TreeSet存储Employee对象，比较两个属性

​ int age, int weight 先按照年龄进行升序排，如果年龄相等的话，按照体重升序排

package com.qfedu.a_treeset;
​
import java.util.Set;
import java.util.TreeSet;
​
class Employee implements Comparable<Employee>{
    String name;
    int age;
    int weight;
​
    public Employee(String name, int age, int weight) {
        this.name = name;
        this.age = age;
        this.weight = weight;
    }
​
    @Override
    public String toString() {
        return "Employee{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", weight=" + weight +
                '}';
    }
​
    @Override
    public int compareTo(Employee o) {
        //先按照年两比，如果年龄相等 就比较体重
        int num = this.age - o.age;
        if (num == 0) {
            int num1 = o.weight - this.weight;
            return num1;
        }
        return num;
    }
}
public class Demo2 {
    public static void main(String[] args) {
        Set<Employee> set = new TreeSet<>();
        set.add(new Employee("你看", 35, 78));
        set.add(new Employee("你说", 26, 70));
        set.add(new Employee("你听", 35, 72));
        set.add(new Employee("不懂", 35, 79));
        set.add(new Employee("以为", 32, 59));
        set.add(new Employee("不懂", 32, 59));
        System.out.println(set);
    }
}
​

总结：使用TreeSet的时候需要类实现一个接口Comparable这个接口去做比较排序

比较器Comparator

案例：

package com.qfedu.b_comparator;
​
import java.util.Comparator;
import java.util.Set;
import java.util.TreeSet;
​
class Student {
    String name;
    int age;
​
    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }
​
    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}
class MyComparator implements Comparator<Student> {
​
    @Override
    public int compare(Student o1, Student o2) {
        int num = o1.age - o2.age;
        return num;
    }
}
public class Demo1 {
    public static void main(String[] args) {
        //如果想要使用比较器的写法 必须再new TreeSet的时候
        //加上比较器对象
        //TreeSet 有一个有参构造，有参构造的方法是Comparwator的对象
        //Comparator是一个接口 不能实例化，咋办？再写一个类去实现这个接口
        Set<Student> students = new TreeSet<>(new MyComparator());
        students.add(new Student("小胖", 23));
        students.add(new Student("小小", 19));
        students.add(new Student("小花", 18));
        students.add(new Student("小光", 28));
        students.add(new Student("小鱼", 36));
        System.out.println(students);
    }
}
​

匿名内部类

作用：减少代码量

基于抽象类的匿名内部类

案例：

package com.qfedu.c_anno;
​
//声明一个抽象列类
abstract class Person {
    public abstract void eat();
    public void sleep() {
        System.out.println("好想逃，然后去睡觉！！！");
    }
}
//常规来讲，新建一个类 去继承抽象类。然后实例化继承的抽象类的类
public class Demo1 {
    public static void main(String[] args) {
        //匿名内部类：在实例化对抽象类同时并重写抽象方法
        Person person = new Person(){
            @Override
            public void eat() {
                System.out.println("吃吃喝喝");
            }
        };
        person.eat();
        person.sleep();
​
    }
}

基于接口的匿名内部类

案例：

package com.qfedu.c_anno;
​
interface A {
    void testA();
​
}
public class Demo3 {
    public static void main(String[] args) {
//        A a = new A(){
//
//            @Override
//            public void testA() {
//                System.out.println("嘻嘻哒");
//            }
//        };
//        a.testA();
        new A(){
​
            @Override
            public void testA() {
                System.out.println("哈哈");
            }
        }.testA();
    }
}

真实开发的时候，一个方法参数是一个接口对象，不用再新建一个类去实现这个接口，直接在方法中new接口

成员内部类

在类的方法的外面，在类中创建的类就是成员内部类

package com.qfedu.d_inner;
​
class MemberDemo {
    String name = "张三";
    int age = 20;
​
    public void printf() {
        System.out.println("打印着玩");
    }
    class Inner {//就是内部类
        String name = "李四";
        //在Inner这个类中可以访问外部类的属性和方法
        public void test () {
            printf();//打印着玩
            System.out.println(age);//20
            System.out.println(name);//李四
            //如果访问外部特定的属性的时候: 类名.this.属性
            System.out.println(MemberDemo.this.name);//张三
        }
    }
​
}
public class Demo1 {
    public static void main(String[] args) {
        //成员内部类的创建步骤：
        //1.实例化外部类 类对象
        MemberDemo memberDemo = new MemberDemo();
        //2.实例化内部类对象，但是new得改为  外部对象.new
        MemberDemo.Inner inner = memberDemo.new Inner();
        inner.test();
​
    }
}
​