树——二分搜索树（Binary Search Tree）

二叉树

二叉树是一种动态的数据结构
二叉树的特点：
1.二叉树具有唯一的根结点
2.二叉树每一个结点最多有两个孩子（叶子结点没有孩子）
3.二叉树每一个结点至多有一个父亲
4.二叉树具有天然递归结构
5.每个结点的左右子树也是二叉树
6.一个层数为k的满二叉树总节点数为2的k次方减一
7.第i层的节点数为2的（i-1）次方
8.层数为k的满二叉树的叶子结点个数为2的k次方减一

二叉树的Java代码实现

/**
     *  定义结点
     *  结点值
     *  左节点
     *  右节点
     */
   
    class  Node{
   
        Integer val;
        Node leftNode;//左孩子
        Node rightNode;//右孩子
        //构造方法初始化结点
        public Node(Integer val) {
   
            this.val = val;
            this.leftNode=null;
            this.rightNode=null;
        }
        public Node() {
   
        }
    }

二分搜索树

二分搜索树是一种二叉树；
二分搜索树的特点：
1.二分搜索树每一个结点的值大于其左节点的值；小于其右节点的值
2.二叉搜索树的每一个子树也是二叉搜索树

简言之，二叉搜索树是一个有插入规则的二叉树

二叉搜索树的Java代码实现

添加元素

  /**二叉搜索树的根节点 */
    Node root;

    /**
     * 将val添加到二叉搜索树中合适的位置
     * @param val 要插入的值
     */
    public void add(T val){
   

      root = add(root,val);
    }
    /**
     * 使用递归进行添加
     * @param root
     * @param val
     * @return
     */
    private Node add(Node root, T val) {
   
        //递归到底情况
        if(null == root){
   
            Node node = new Node(val);
            return node;
        }

        //递归操作
        if(val.compareTo(root.data) > 0){
   
           root.right =  add(root.right,val);
        }else{
   
           root.left =  add(root.left, val);
        }
        return root;
    }

查找二叉树中的元素并返回与目标值同值的子树

 public Node isContains(T data){
   
       return  isContains(root,data);
    }

    private Node isContains(Node root, T data) {
   
        //递归到底的情况
        if(root == null){
   
            return null;
        }
        if(data.compareTo(root.data) ==0){
   
            return root;
        }else if(data.compareTo(root.data)>0){
   
            return isContains(root.right,data);
        }else{
   
            return isContains(root.left,data);
        }
    }

查找最大最小值结点

 //查找最小结点,一直向左找
    public Node getMin(){
   
        return getMin(root);
    }

    private Node getMin(Node node) {
   
        if (node.leftNode==null){
   
            return node;
        }else {
   
            getMin(node.leftNode);
        }
        return node;
    }
    //查找最大值结点
    public Node getMax(){
   
        return getMax(root);
    }
    private Node getMax(Node node) {
   
        if (node.rightNode==null){
   
            return node;
        }else {
   
            getMin(node.rightNode);
        }
        return node;
    }
      public Node mixNodeDG(){
   
        if(root==null){
   
            return null;
        }
      return  mixNodeDG(root);

    }

    private Node mixNodeDG(Node root) {
   
        //递归到底