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;
}

//添加節(jié)點
	//此方法可以類內(nèi)部方法的調(diào)用
    private void add(Node root,int value){
        //添加節(jié)點的值大于根節(jié)點的值，該節(jié)點添加到根節(jié)點的右子樹上
        if(value > root.value){
            //根節(jié)點的右子樹為空，直接添加
            if(root.right == null){
                root.right = new Node(value);
            }
            //根節(jié)點右子樹不為空，遞歸往右子樹插
            else{
                add(root.right,value);
            }
        }
        //添加節(jié)點的值小于或者等于根節(jié)點的值，該節(jié)點應該添加到左子樹
        else{
            //左子樹為空，直接添加
            if(root.left == null){
                root.left = new Node(value);
            }
            //左子樹不為空，遞歸往左子樹添加
            else{
                add(root.left, value);
            }
        }
    }
    //此方法在類內(nèi)部和類外部都可以調(diào)用
    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);
    }

/**
     * 通過value查找二叉樹中的節(jié)點
     * @param root 被查找樹的根節(jié)點
     * @param value 要查找的值
     * @return 返回查找到的節(jié)點
     */
    private Node searchNode(Node root, int value){
        //被查找樹為null，要查找節(jié)點不存在
        if(root == null)
            return null;
        //找到了，返回節(jié)點
        else if(root.value == value){
            return root;
        }
        //該節(jié)點不是要查找節(jié)點，繼續(xù)查找
        else{
            //該節(jié)點的值大于value，往該節(jié)點的左子樹遞歸查找
            if(root.value > value){
                return searchNode(root.left, value);
            }
            //該節(jié)點的值小于value,往該節(jié)點的右子樹遞歸查找
            else{
                return searchNode(root.right, value);
            }
        }
    }

 /**
     * 查找某節(jié)點的父節(jié)點，并返回
     * @param root 被查找樹的根節(jié)點
     * @param node 要查找的節(jié)點
     * @return 返回被查找節(jié)點的父節(jié)點
     */
    private Node searchParentNode(Node root, Node node){
        //被查找樹為null或者根節(jié)點就是要查找的節(jié)點，那么要查找節(jié)點的父節(jié)點不存在
        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){
        //找到要刪除的節(jié)點
        Node targetNode = searchNode(root,vlaue);
        //要刪除節(jié)點不存在
        if(targetNode == null) return;
        //找到要刪除節(jié)點的父節(jié)點
        Node targetNodeParent = searchParentNode(root,targetNode);
        //要刪除節(jié)點為葉子節(jié)點
        if(targetNode.left == null && targetNode.right == null){
            //要刪除的節(jié)點就是根節(jié)點
            if(targetNodeParent == null){
              root = null;
            }
            else{
                //要刪除節(jié)點是其父節(jié)點的左節(jié)點
                if(targetNodeParent.left == targetNode){
                    targetNodeParent.left = null;
                }
                else{
                    targetNodeParent.right = null;
                }
            }
        }
        //要刪除節(jié)點只有一個左子樹
        else if(targetNode.left != null && targetNode.right == null){
            //要刪除的節(jié)點就是根節(jié)點
            if(targetNodeParent == null) {
                root = root.left;
            }
            //要刪除節(jié)點是其父節(jié)點的左節(jié)點
            else if(targetNodeParent.left != null && targetNodeParent.left.value == targetNode.value){
                targetNodeParent.left = targetNode.left;
            }
            //要刪除節(jié)點是其父節(jié)點的右節(jié)點
            else{
                targetNodeParent.right = targetNode.left;
            }
        }
        //要刪除節(jié)點只有一個右子樹
        else if(targetNode.right != null && targetNode.left == null){
            //要刪除的節(jié)點就是根節(jié)點
            if(targetNodeParent == null) {
                root = root.right;
                return;
            }
            //要刪除節(jié)點是其父節(jié)點的左節(jié)點
            else if(targetNodeParent.left != null && targetNodeParent.left.value == targetNode.value){
                targetNodeParent.left = targetNode.right;
            }
            //要刪除節(jié)點是其父節(jié)點的右節(jié)點
            else{
                targetNodeParent.right = targetNode.right;
            }
        }
        //要刪除節(jié)點右左右都有節(jié)點
        else{
            //找到右子樹最小的節(jié)點
            Node minNode = targetNode.right;
            while(minNode.left != null){
                minNode = minNode.left;
            }
            int temp = minNode.value;
            //找到右子樹上最小節(jié)點的父節(jié)點
            Node minNodeParent = searchParentNode(targetNode.right,minNode);
            //右子樹根節(jié)點就是最小節(jié)點
            if(minNodeParent == null){
                targetNode.right = minNode.right;
            }
            else{
                //要刪除節(jié)點是其父節(jié)點的左節(jié)點
                minNodeParent.left = minNode.right;
            }
            targetNode.value = temp;
        }
    }