二分搜索树(Binary Search Tree )

树结构：就是和现实中的树一样一个树根开出很多枝叶
树倒过来：

二叉树：只有两个枝杈的树。（多叉树）
1、具有天然的递归结构
2、二叉树不一定是满的

3、二分搜索树是二叉树
4、二分搜索树的每个节点的值：大于其左子树的所有结点的值
小于其右子树的值
5、存储的数据必须要有可比较性
(“凡事都有代价，出来混迟早要还的”)

还是不太理解。。。。

public class BST<E extends Comparable<E>> {

    //节点类
    private class Node{
        public E e;//结点元素
        public Node left;//结点的左孩子
        public Node right;//结点的右孩子

        //构造函数 初始化
        public Node(E e){
            this.e=e;
            left=null;
            right=null;
        }
    }

    private Node root;//根节点
    private int size;//树中元素个数

    //构造函数 初始化
    public BST(){
        root=null;
        size=0;
    }

    //获取元素个数
    public int getSize(){
        return size;
    }

    //判断树是否为空
    public boolean isEmtpy(){
        return size==0;
    }

    //二分搜索树添加元素
    public void add(E e){
        if (root==null){
            root=new Node(e);
            size++;
        }else{
            add(root,e);
        }
    }

    //向以node为根的二分搜索树中插入元素e，递归算法
    private void add(Node node,E e){

        if (e.equals(node.e)){
            return ;
        }else if (e.compareTo(node.e)<0&&node.left==null){
            node.left=new Node(e);
            size++;
        }else if (e.compareTo(node.e)>0&&node.right==null){
            node.right=new Node(e);
            size++;
        }

        if (e.compareTo(node.e)<0){
            add(node.left,e);
        }else{
            add(node.right,e);
        }

    }

    //看二分搜索树是否包含元素e，
    public boolean contains(E e){
        return contains(root,e);
    }

    //看以node为根的二分搜索树中是否包含元素e，递归算法
    private boolean contains(Node node,E e){
        if (node==null){
            return false;
        }

        if (e.compareTo(node.e)==0){
            return true;
        }
        else if (e.compareTo(node.e)<0){
            return contains(node.left,e);
        }else{
//            node=node.right;
             return contains(node.right,e);
        }
    }

    //二分搜索树的前序遍历
    public void preOrder(){
        preOrder(root);
    }
    //二分搜索树的前序遍历 递归算法
    private void preOrder(Node node){
        if (node == null) {
            return;
        }
        System.out.println(node.e);
        preOrder(node.left);
        preOrder(node.right);
    }

    //二分搜索树的中序遍历
    public void inOrder(){
        inOrder(root);
    }
    //二分搜索树的前序遍历 递归算法
    private void inOrder(Node node){
        if (node == null) {
            return;
        }
        inOrder(node.left);
        System.out.println(node.e);
        inOrder(node.right);
    }

    //二分搜索树的后序遍历
    public void postOrder(){
        postOrder(root);
    }
    //二分搜索树的前序遍历 递归算法
    private void postOrder(Node node){
        if (node == null) {
            return;
        }
        postOrder(node.left);
        postOrder(node.right);
        System.out.println(node.e);
    }


    public static void main(String[] argc){
        BST<Integer> bst=new BST<>();
        int[] nums={6,5,4,3,2,1};
//        int[] nums={5,3,6,8,4,2};
        ////////////////////////
        //              6
        //            /   \
        //           5     4
        //          / \   /  \
        //         1   2      3
        for (int num:nums){
            bst.add(num);
        }

        bst.preOrder();//前序遍历 6,5,4,3,2,1
        System.out.println();
        bst.inOrder();//中序遍历  5 4 3 2 1 6
        System.out.println();
        bst.postOrder();//后序遍历  5 4 3 2 1 6

    }
}