搜索二叉树的手写

/**
 * 文件描述：手写二叉搜索树（左小右大的）
 * 作者：chenjingkun708
 * 创建时间：2020/3/24
 * 更改时间：2020/3/24
 */
public class MyBinarySearchTree {
    public Node root;//树的根节点

    public MyBinarySearchTree() {
    }

    /*
          前序遍历,打印的顺序依次是：根，左，右节点
         */
    public void frontTravesal(Node root){
        if (root==null){
            return;
        }
        Log.i("android_test", String.valueOf(root.value));
        frontTravesal(root.left);
        frontTravesal(root.right);
    }

    /*
      中须遍历
     */
    public void centerTravesal(Node root){
        if (root==null){
            return;
        }
        centerTravesal(root.left);
        Log.i("android_test",String.valueOf(root.value));
        centerTravesal(root.right);
    }

    /*
      后序遍历
     */
    public void lastTravesal(Node root){
        if (root==null){
            return;
        }
        lastTravesal(root.left);
        lastTravesal(root.right);
        Log.i("android_test",String.valueOf(root.value));
    }

    //查找:利用特性：左小右大，递归
    public boolean find(int target){
        return find(root,target)==null?false:true;
    }

    private Node find(Node root,int target){
        if (root==null){
            return null;
        }
        if (root.value==target){
            return root;
        }
        if (target<root.value){
            return find(root.left,target);
        }else {
            return find(root.right,target);
        }
    }

    //删除，因为要涉及到移动，可采取一些办法来实现。可能会有点问题
    public boolean delete(int target){
         Node node = find(root,target);
         if (node==null){
             return false;
         }
         //1.向右查找最大的节点
         Node maxNode = popReplace(node);
         //2. 把目标值用最大值代替
         node.value = maxNode.value;
         //3.向下沉去纠正节点
         shritDownNode(node);
         return true;
    }

    //下沉去纠正节点
    private void shritDownNode(Node curNode) {
        if (curNode==null){
            return;
        }
        if (curNode.left!=null&&curNode.value<curNode.left.value){
            //交换节点
            Node leftNode = curNode.left;

            Node tempNode = leftNode;

            leftNode.value = curNode.value;
            leftNode.left = curNode.left;
            leftNode.right = curNode.right;

            curNode.value = tempNode.value;
            curNode.left = tempNode.left;
            curNode.right = tempNode.right;
            shritDownNode(curNode);
        }else if (curNode.right!=null&&curNode.value>curNode.right.value){
            //交换节点
            Node rightNode = curNode.right;

            Node tempNode = rightNode;

            rightNode.value = curNode.value;
            rightNode.left = curNode.left;
            rightNode.right = curNode.right;

            curNode.value = tempNode.value;
            curNode.left = tempNode.left;
            curNode.right = tempNode.right;
            shritDownNode(curNode);
        }
        return;
    }

    //弹出最右边的右节点或左节点
    private Node popReplace(Node root){
        if (root.right==null){
            return root;
        }
        Node maxNode = popReplace(root.right);

        if (maxNode.left!=null){
            Node leftNode = maxNode.left;
            maxNode.left = null;
            return leftNode;
        }else {
            root.right = null;
            return maxNode;
        }
    }

    //插入值
    public void add(int value){
        addNode(value,root);
    }
    //采用递归的方式
    private Node addNode(int value,Node curNode){
        if (curNode==null){
            return new Node(value,null,null);
        }
        if (value<curNode.value){
            curNode.left = addNode(value,curNode.left);
        }else if (value>curNode.value){
            curNode.right = addNode(value,curNode.right);
        }else{
            curNode.value = value;
        }
        return curNode;
    }


    //判断是不是自平衡的搜索二叉树：左右子树的高度不超过1，并且子树也是一个平衡二叉树
    public boolean isBalanceTree(Node node){
        if (node==null){
            return true;
        }
        int leftDep = getTreeDeep(node.left);
        int rightDep = getTreeDeep(node.right);
        return Math.abs(leftDep-rightDep)<=1&&isBalanceTree(node.left)&&isBalanceTree(node.right);
    }

    //获取树或子树的深度
    public int getTreeDeep(Node childRoot) {
        if (childRoot==null){
            return 0;
        }
        int leftDep,rightDep;
        leftDep = getTreeDeep(childRoot.left)+1;
        rightDep = getTreeDeep(childRoot.right)+1;
        return leftDep>rightDep?leftDep:rightDep;
    }


    /*
      树节点类表示
     */
    public static class Node{
        int value;
        //左孩子
        public Node left;
        //右孩子
        public Node right;

        public Node(int value, Node left, Node right) {
            this.value = value;
            this.left = left;
            this.right = right;
        }
    }
}