二叉排序树的创建，遍历，删除

package day21;

import com.sun.xml.internal.bind.v2.util.StackRecorder;
import org.omg.CORBA.PUBLIC_MEMBER;

public class 二叉排序树 {
//   左节点小于根节点，右节点大于跟节点
public static void main(String[] args) {
    Binarysortree binarysortree = new Binarysortree();
    int[] arr ={ 7,3,10,12,5,1,9,2};
for (int i=0;i<arr.length;i++){
    Node node = new Node(arr[i]);
    binarysortree.add(node);
//    binarysortree.delnode(1);
    binarysortree.delnode(10);

}
    System.out.println("中序遍历二叉排序树 ");
binarysortree.indixorder();
}
}
//创建二叉排序树
//--------------------------------------------------tree---------------------------------------------
class Binarysortree{
    private Node root;
public void add(Node node){
    if (root ==null){
        root=node;
    }else {
        root.add(node);
    }
}
public void indixorder(){
    if (root!=null){
        root.indixorder();
    }else {
        System.out.println("二叉排序树为空");
    }
}
public Node search(int value){
    if (root==null){
        return null;
    }else {
        return root.search(value);
    }
}
//查找父节点
public Node searchParent(int value){

    if (root==null){
        return null;
    }else {
        return root.searchparent(value);
    }

}
//返回最小节点的值
//    删除node为根节点的二叉排序树的最小节点

    /**
     *
     *
     * @param node 当作二叉排序树的根节点
     * @return   返回以node为二叉排序树根节点最小的值
     */
    public int delrighttreemin(Node node){
    Node target =node;
//    循环查找左子节点，找最小值
        while (target.left!=null){
            target=target.left;
        }
//        这时，target为最小节点
//        删除他
        delnode(target.value);
    return target.value;
    }



//删除节点
    public void delnode(int value){
    if (root==null){
        return;
    }else {
//      先找到要删除的节点
        Node searchnode = search(value);
//      如果没有找到要删除的节点
        if (searchnode==null){
            return;
        }
        //如果只有一个root节点
        if (root.left==null&&root.right==null){
            root =null;
            return;
        }
//        去找到serachnode的父节点
        Node parent = searchParent(value);
        //如果要删除的节点是叶子节点
        if (searchnode.left==null&&searchnode.right==null){
//            判断searchnode是左还是右
            if (parent.left!=null&&parent.left.value==value){ //左
                parent.left =null;
            }else if (parent.right!=null&&parent.right.value==value){ //右
                parent.right=null;
            }

        }else if (searchnode.left!=null&&searchnode.right!=null){
            //要删除的节点是两颗字数的节点
            int minvalue = delrighttreemin(searchnode.right);
            searchnode.value=minvalue;

        }else { //删除只有一颗子树的节点
//            删除的节点有左子节点
            if (searchnode.left != null) {
//                如果删除的节点处于左节点
                if (parent.left.value == value) {
                    parent.left = searchnode.left;
                } else {
                    //删除的节点处于右节点
                    parent.right = searchnode.left;
                }
            } else {//要删除的节点有右子节点
//            如果删除的节点处于父节点的左
                if (parent.left.value == value) {
                    parent.left =searchnode.right;
                }else { //删除的节点处于父节点的右
                    parent.right=searchnode.right;
                }

            }
        }

    }

    }

}

//-----------------------------------------------------node-------------------------------------------

class Node{
    int value;
    Node left;
    Node right;

    @Override
    public String toString() {
        return "Node{" +
                "value=" + value +
                '}';
    }

    public Node(int value) {
        this.value = value;
    }
//    添加节点
    public void add(Node node){
//        递归添加，需要满足二叉排序树
        if (node==null){
            return;
        }
//       判断传入的节点的值和当前二叉树跟节点比较
        if (node.value<this.value){ //this为根节点
            if (this.left==null){
                this.left=node;
            }else {
                this.left.add(node);//递归的向左子树添加
            }

        }else {//node>value
            if (node.value>this.value){
                if (this.right==null){
                    this.right=node;
                }else {
                    this.right.add(node);//递归添加
                }
            }
        }

    }

//    中序遍历
    public void indixorder(){  //左中右
        if (this.left!=null){
            this.left.indixorder();
        }
        System.out.println(this);
        if (this.right!=null){
            this.right.indixorder();
        }
    }



    //查找要删除的节点
    public Node search(int value){
//     因为在node类中的方法，不需要判断空
        if (value==this.value){
            return this;
        }else if(value<this.value){
//            向左走 ,判空
            if (this.left==null){
                return null;
            }
           return this.left.search(value);
        }else{
//            向右走，判空
            if (this.right==null){
                return null;
            }
            return this.right.search(value);
        }
    }
    //查找删除节点的父节点
    public Node searchparent(int value){
        if (this.left!=null &&this.left.value==value||this.right!=null&&this.right.value==value){
//说明这个节点为要删除节点的父节点
            return this;
        }else if (this.value<value &&this.right!=null){
                return this.right.searchparent(value);
            }else if (this.value>=value&&this.left!=null){
            return this.left.searchparent(value);
        }else {
            return null; //没有找到
        }


    }

}