Java超详细讲解排序二叉树

public class binarySortTree {
    class node{
        int value;
        Node left;
        Node right;
        public Node(int value){
            this.value = value;
        }
        public void display(){
            System.out.print(this.value + " ");
        }
    }
    Node root;
}

//添加节点
	//此方法可以类内部方法的调用
    private void add(Node root,int value){
        //添加节点的值大于根节点的值，该节点添加到根节点的右子树上
        if(value > root.value){
            //根节点的右子树为空，直接添加
            if(root.right == null){
                root.right = new Node(value);
            }
            //根节点右子树不为空，递归往右子树插
            else{
                add(root.right,value);
            }
        }
        //添加节点的值小于或者等于根节点的值，该节点应该添加到左子树
        else{
            //左子树为空，直接添加
            if(root.left == null){
                root.left = new Node(value);
            }
            //左子树不为空，递归往左子树添加
            else{
                add(root.left, value);
            }
        }
    }
    //此方法在类内部和类外部都可以调用
    public void add(int value){
        //当前树为空树
        if(root == null){
            root = new Node(value);
            return;
        }
        add(root, value);
    }

//中序遍历树
    private  void inPrevOrder(Node root){
        if(root == null) return;
        inPrevOrder(root.left);
        root.display();
        inPrevOrder(root.right);
    }
    public void inPrevOrder(){
        System.out.print("中序遍历：");
        inPrevOrder(root);
    }

    private Node searchNode(Node root, int value){
        //被查找树为null，要查找节点不存在
        if(root == null)
            return null;
        //找到了，返回节点
        else if(root.value == value){
            return root;
        }
        //该节点不是要查找节点，继续查找
        else{
            //该节点的值大于value，往该节点的左子树递归查找
            if(root.value > value){
                return searchNode(root.left, value);
            }
            //该节点的值小于value,往该节点的右子树递归查找
            else{
                return searchNode(root.right, value);
            }
        }
    }

 
    private Node searchParentNode(Node root, Node node){
        //被查找树为null或者根节点就是要查找的节点，那么要查找节点的父节点不存在
        if(root == null || root == node){
            return null;
        }
        else if(root.left != null && root.left == node || root.right != null && root.right == node){
            return root;
        }
        else{
            if(root.value > node.value){
                return searchParentNode(root.left, node);
            }
            else{
                return searchParentNode(root.right, node);
            }
        }
    }

public void remove(int vlaue){
        //找到要删除的节点
        Node targetNode = searchNode(root,vlaue);
        //要删除节点不存在
        if(targetNode == null) return;
        //找到要删除节点的父节点
        Node targetNodeParent = searchParentNode(root,targetNode);
        //要删除节点为叶子节点
        if(targetNode.left == null && targetNode.right == null){
            //要删除的节点就是根节点
            if(targetNodeParent == null){
              root = null;
            }
            else{
                //要删除节点是其父节点的左节点
                if(targetNodeParent.left == targetNode){
                    targetNodeParent.left = null;
                }
                else{
                    targetNodeParent.right = null;
                }
            }
        }
        //要删除节点只有一个左子树
        else if(targetNode.left != null && targetNode.right == null){
            //要删除的节点就是根节点
            if(targetNodeParent == null) {
                root = root.left;
            }
            //要删除节点是其父节点的左节点
            else if(targetNodeParent.left != null && targetNodeParent.left.value == targetNode.value){
                targetNodeParent.left = targetNode.left;
            }
            //要删除节点是其父节点的右节点
            else{
                targetNodeParent.right = targetNode.left;
            }
        }
        //要删除节点只有一个右子树
        else if(targetNode.right != null && targetNode.left == null){
            //要删除的节点就是根节点
            if(targetNodeParent == null) {
                root = root.right;
                return;
            }
            //要删除节点是其父节点的左节点
            else if(targetNodeParent.left != null && targetNodeParent.left.value == targetNode.value){
                targetNodeParent.left = targetNode.right;
            }
            //要删除节点是其父节点的右节点
            else{
                targetNodeParent.right = targetNode.right;
            }
        }
        //要删除节点右左右都有节点
        else{
            //找到右子树最小的节点
            Node minNode = targetNode.right;
            while(minNode.left != null){
                minNode = minNode.left;
            }
            int temp = minNode.value;
            //找到右子树上最小节点的父节点
            Node minNodeParent = searchParentNode(targetNode.right,minNode);
            //右子树根节点就是最小节点
            if(minNodeParent == null){
                targetNode.right = minNode.right;
            }
            else{
                //要删除节点是其父节点的左节点
                minNodeParent.left = minNode.right;
            }
            targetNode.value = temp;
        }
    }