TreeMap、二叉树

前面我们学习了

Collection下面有：
1、List(ArrayList、LinkedList、Vector)，重点我们理解了线程安全和不安全
2、Set下面的HashSet

Map下面的HashMap。
其中HashSet是基于HashMap实现的(就是HashMap的key，不重复)。

TreeMap

我们使用HashMap加入一些数据，但这些数据不能排序。

        Map<String,Integer> users = new TreeMap<String,Integer>();
        users.put("jack",19);
        users.put("lily",20);
        users.put("susan",22);
        users.put("robin",27);

        // 对users遍历
        for (Map.Entry<String,Integer> entry: users.entrySet()){
            System.out.println(entry.getKey()+":"+entry.getValue());
        }

打印结果：

jack:19
lily:20
robin:27
susan:22

可以看出TreeMap的对象遍历的时候默认是针对其key排序的。

如果我们要自定义排序方式，比如上面的排序 我们要倒序。

        Map<String,Integer> users = new TreeMap<String,Integer>(new Comparator<String>() {
            @Override
            public int compare(String o1, String o2) {
                return o2.compareTo(o1);
            }
        });

        users.put("jack",19);
        users.put("lily",20);
        users.put("susan",22);
        users.put("robin",27);

        // 对users遍历
        for (Map.Entry<String,Integer> entry: users.entrySet()){
            System.out.println(entry.getKey()+":"+entry.getValue());
        }

我们注意到new TreeMap里我们传入了Comparator对象，内部把o2和o1的ASCII码值进行比较。
现在输出结果：

susan:22
robin:27
lily:20
jack:19

按照字符串长度以及ASCII码进行比较：

        Map<String,Integer> users = new TreeMap<String,Integer>(new Comparator<String>() {
            @Override
            public int compare(String o1, String o2) {
                return (o1.length()-o2.length()) + o1.compareTo(o2);
            }
        });

最后结果如下：

jack:19
lily:20
robin:27
susan:22

TreeMap是一个树结构

前面我们接触的ArrayList它是一个数组结构，LinkedList，它是一个链表结构。

比较简单的『树结构』就是二叉树，又称二叉查找树/二叉搜索树。
1、有个树根：Root
2、作用拥有2个子树(子节点)
3、左边子节点的值比自己小，右边子节点的只比自己大

写代码

1、写一个二叉树类BTree.java：

// 二叉树类
public class BTree {

    public Node root = null; //二叉数的根节点

    // 插入数据的方法
    public void put(int data){
        if (this.root == null){
            this.root = new Node(data);
        }else {
            this.root = this.addNode(root,data);
        }
    }

    // 添加节点
    private Node addNode(Node node,int data){
        if (node == null){
            return new Node(data);
        }

        if (data < node.selfData){
            node.leftNode = addNode(node.leftNode,data);
        }else if (data > node.selfData){
            node.rightNode = addNode(node.rightNode,data);
        }

        return node;
    }

    public void List(){
        List(root);
    }
    // 递归遍历所有节点
    public void List(Node n){
        if (n != null){
            List(n.leftNode); //递归
            System.out.println(n.selfData);
            List(n.rightNode);
        }
    }


    // 节点类
    class Node{
        private  Node leftNode = null; //左节点
        private  Node rightNode = null; //右节点
        private int selfData; //节点自身的数据

        // 构造函数
        public Node(int selfData) {
            this.selfData = selfData;
        }
    }
}

2、调用这个类，往二叉树对象里插入数据，最后遍历

        // 实例化二叉树
        BTree bTree = new BTree();

        // 插入数据
        bTree.put(5); //这就是树根
        bTree.put(3);
        bTree.put(7);
        bTree.put(2);
        bTree.put(9);
        bTree.put(8);
        bTree.put(1);
        bTree.put(6);

        // 显示二叉树对象中的所有数据
        bTree.List();

最后遍历打印结果如下：

1
2
3
5
6
7
8
9

如果要倒序，在BTree类的List()方法中就先打印右节点，后打印左节点：

    // 递归遍历所有节点
    public void List(Node n){
        if (n != null){
            List(n.rightNode); //递归
            System.out.println(n.selfData);
            List(n.leftNode);
        }
    }