泛型与set集合与二叉树

二叉树&set集合&泛型

目标如下

1,会使用泛型
2,会使用set集合,使用TreeSet进行排序
3,了解二叉树

泛型

Java中如果在写代码的时候，不知道数据类是什么类型，那么就可以使用泛型。泛型其实就是任意的数据类型。

泛型可以使用在哪些地方？
	泛型类： 在类名后面<T>, 它表示在类中有一个不确定的数据类型。
	泛型方法： 在方法的返回值前面<T>，它表示在方法中有一个不确定的数据类型
	泛型接口：在接口名后面<T>，它表示在接口中有一个不确定的数据类型

泛型类

在类名后面<T>, 它表示在类中有一个不确定的数据类型、

//定义一个盒子，用来装东西(什么东西，不知道)
public class Box<T>{
    T t; //盒子里面装的是T类型的数据
    
    public void setT(T t){
        this.t=t;
    }
    
    public T getT(){
        return t;
    }
}

创建Box类的对象，创建对象的是同时确定泛型的数据类型

public class Test1{
    public static void main(String[] args){
        //创建Box对象，同时确定泛型<T>为<String>类型
        Box<String> b=new Box<>(); 
        b.setT("我太会了");
        String s1=b.getT();
        System.out.println(s1); //我太会了
        
        //创建Box对象，同时确定泛型<T>为<Integer>类型
        Box<Integer> b=new Box<>();
        b.setT(453);
        Integer s2=b.getT();
        System.out.println(s2); //453
    }
}

泛型方法

在方法的返回值前面，它表示在方法中有一个不确定的数据类型。当调用方法时确定泛型的数据类型。

public static void main(String[] args){
	//确定addElement方法的<T>为<String>类型
    ArrayList<String> list1=new ArrayList<>();
    addElement(list1,"a","b","c");
    
    //确定addElement方法的<T>为<Integer>类型
    ArrayList<Integer> list2=new ArrayList<>();
    addElement(list2,1,2,3); 
}

//<T>表示一个在方法中不确定的数据类型
public static <T> void addElement(ArrayList<T> list, T t1, T t2, T t3){
    list.add(t1);
    list.add(t2);
    list.add(t3);
}

泛型接口

在接口名后面，它表示在接口中有一个不确定的数据类型

public interface Inter<T>{
    public void method(T t);
}

• 接口上的泛型可以在实现类中确定其数据类型

public class InterImpl implements Inter<String>{
    public void method(String t){
        System.out.println(t);
    }
}

• 把接口上的泛型沿用到实现类上，再创建对象的时候来确定其数据类型

public class InterImpl<T> implements Inter<T>{
    public void method(T t){
        System.out.println(t);
    }
}

public class Test3{
    public static void main(String[] args){
        InterImpl<String> impl=new InterImpl();
        impl.method("我太会了");
        
        InterImpl<Integer> impl=new InterImpl();
        impl.method(453);
    }
}

泛型的总结

1、类上的泛型<T>： 创建该类对象时，确定<T>的数据类型。

2.方法上的泛型<T>：调用方法的时候，确定<T>的数据类型。

3.接口上的泛型<T>：
	1)在实现类上确定<T>的数据类型
	2)把泛型<T>沿用到实现类上，在创建实现类对象来确定<T>的数据类型

泛型限定

?: 表示任意的类型
?  extends  Number: Number或者Number的子类
?  super  Number:  Number或者Number的父类

Set集合

Set集合的特点：没有索引，元素不能重复
	--HashSet：元素是没有顺序
	--TreeSet：它可以对集合中的元素进行排序

TreeSet类有

TreeSet集合可以对元素进行排序。有两种排序方式。

• 自然排序：让元素的类实现Comparable接口，复写compareTo方法

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

    //省略构造方法，自己加上即可

    //实现Comparable接口重写方法来告诉TreeSet排序的规则
    @Override
    public int compareTo(Student o) {
        //先按照成绩排序，
        int num=this.score-o.score;
        //如果成绩相同，再按照年龄排序
        if(num==0){
            num=this.age-o.age;
        } 
        return num;
    }
}

• 比较器排序Comparator，让集合具备比较规则。

//创建TreeSet集合，同时指定排序规则 需要一个Comparator对象。
TreeSet<Teacher> ts=new TreeSet<>(new Comparator<Teacher>() {
    @Override
    public int compare(Teacher o1, Teacher o2) {
        //o1和o2 表示集合中已有的两个元素
        //按照年龄升序排列
        int num=o1.getAge()- o2.getAge();
        //如果年龄相同，就按照姓名进行比较
        if(num==0){
            num=o1.getName().compareTo(o2.getName());
            if(num==0){
                //...
            }
        }
        return num; 
    }
}); 

ts.add(new Teacher("zhagnasn",20));
ts.add(new Teacher("lisi",21));
ts.add(new Teacher("wangwu",22));
ts.add(new Teacher("aaaa",22));
ts.add(new Teacher("zhaoliu",24));
ts.add(new Teacher("zhaoliu",24));

for (Teacher t : ts) {
    System.out.println(t);
}

二叉树

二叉树： 每一个节点，它最多有两个子节点

二叉查找树(二叉排序树、二叉搜索树)：

（1） 左边的子节点都比这个数小

（2） 右子节点都比这个数大。

（3） 任意节点的左、右子树也分别为二叉查找树；

（4） 没有键值相等的节点。


 二叉平衡树：每一个节点，左右两个子树的高度差不超过1,并且左右两个子树都是一棵平衡二叉树。
	
如果一个二叉树不平衡，如何达到平衡？
	左旋：如果右子树比左子树的高度差大于1，就需要左旋
	右旋：如果左子树比右子树的高度差大于1，就需要右旋
	
破坏平衡二叉树的几种情况，如何再次达到平衡
	左左：在左子树的左边添加元素，直接右旋即可
	左右：在左子树的右边添加元素，先左旋再右旋
	
	右右：在右子树的右边添加元素，直接左旋即可
	右左：在右子树的左边添加元素，先右旋再左旋