Build a binary sort tree, add nodes, delete nodes

package org.structure.tree;

/**
 * 二叉排序树的增加节点，删除节点
 * @author cjj_1
 * @date 2020-08-31 15:06
 */
public class BinarySortTreeDemo {
    
    
    public static void main(String[] args) {
    
    
        BinaryTrees bt = new BinaryTrees();
        int[] arr = {
    
    7,3,10,12,5,1,9};
        for (int i :arr){
    
    
             Node node = new Node(i);
            bt.add(node);
        }
        bt.delete(new Node(9));
        bt.root.infixOrder();
    }

}
class BinaryTrees {
    
    
    Node root;
    Node parent;

    public void add(Node node) {
    
    
        if (root == null) {
    
    
            root = node;
        } else {
    
    
            root.add(node);
        }
    }
    public void delete(Node node) {
    
    
        Node temp = root;
        Node cover_node;
        //要删除的是跟节点
        if (temp.value == node.value) {
    
    
            if (temp.left != null) {
    
    
                cover_node = deleteLeftMaxNode(temp, temp.left,0);
                if (cover_node != temp.left)
                    cover_node.left = temp.left;
                cover_node.right = temp.right;
                root = cover_node;
            } else if (temp.right != null) {
    
    
                cover_node = deleteRightMinNode(temp, temp.left,1);
                if (cover_node != temp.right)
                    cover_node.right = temp.right;
                cover_node.left = temp.left;
                root = cover_node;
            }else {
    
    
                root = null;
            }
        } else {
    
    
            //二叉排序树找节点
            if (node.value > temp.value) {
    
    
                delete(temp, temp.right, node, 1);
            } else {
    
    
                delete(temp, temp.left, node, 0);
            }
        }
    }

    public void delete(Node parent, Node node, Node delNode, int flag) {
    
    
        Node cover_node;
        if (node.value == delNode.value) {
    
    
            if (node.left != null) {
    
    
                cover_node = deleteLeftMaxNode(node, node.left,0);
                if (cover_node != node.left)
                    cover_node.left = node.left;
                cover_node.right = node.right;
                if(flag ==0)
                     parent.left = cover_node;
                else parent.right = cover_node;
            } else if (node.right != null) {
    
    
                cover_node = deleteRightMinNode(node, node.right,1);
                if (cover_node != node.right)
                    cover_node.right = node.right;
                cover_node.left = node.left;
                if(flag ==0)
                    parent.left = cover_node;
                else parent.right = cover_node;
            } else {
    
    //是叶子节点
                if (flag == 0)
                    parent.left = null;
                else parent.right = null;
            }
        } else if (delNode.value > node.value) {
    
    
            delete(node, node.right, delNode, 1);
        } else if (delNode.value < node.value) {
    
    
            delete(node, node.left, delNode, 0);
        }
    }

    /**
     * 查找左子树的 最大的节点
     *
     * @param node
     * @return
     */
    public Node deleteLeftMaxNode(Node parent, Node node,int flag) {
    
    
        Node temp;
        if (node.right != null) {
    
    
            return deleteLeftMaxNode(node, node.right,1);
        } else {
    
    
            if(flag ==1)
             parent.right = null;
            else parent.left =null;
            return node;
        }

    }

    /**
     * 查找右子树的最小节点
     *
     * @param node
     * @return
     */
    public Node deleteRightMinNode(Node parent, Node node,int flag) {
    
    
        if (node.left != null) {
    
    
            return deleteRightMinNode(node, node.left,0);
        } else {
    
    
            if(flag ==0)
                parent.left = null;
            else parent.right = null;
            return node;
        }
    }
}

class Node{
    
    
    Integer value;
    Node left;
    Node right;

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

    @Override
    public String toString() {
    
    
        return "Node{" +
                "value=" + value +
                '}';
    }
    public  void add(Node node){
    
    
        if(this.value > node.value){
    
    
            if(this.left == null){
    
    
                this.left = node;
            }else {
    
    
                this.left.add(node);
            }
        }else {
    
    
            if(this.right== null){
    
    
                this.right= node;
            }else {
    
    
                this.right.add(node);
            }

        }
    }

//    /**
//     * 删除一个节点
//     * @param node
//     */
//    public  void delete(Node node){
    
    
//        if(this.value == node.value){
    
    
//
//        }
//    }

    /**
     * 中序遍历
     */
    public  void infixOrder(){
    
    
        if(this.value == null){
    
    
            return;
        }
        if(this.left!=null){
    
    
            this.left.infixOrder();
        }
        System.out.println(this.value);
        if(this.right!=null){
    
    
            this.right.infixOrder();
        }
    }
}