二叉排序树(JAVA实现)

二叉排序树BTS:对于二叉排序树的任何一个飞叶子结点，要求左子结点的值比当前结点值小，右子结点比当前结点值大

二叉排序树创建

class BTStree{
    private treenode root;
    //添加结点方法
    public void BTScreat(treenode node){
        if(root==null) root=node;
        else
            root.add(node);
    }
}
class treenode{
    private int value;
    private treenode left;
    private treenode right;

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

    //结点添加
    public void add(treenode node){
        //本结点值大于添加节点，应放在左子结点
        if(this.value>node.value)
        {
            if (left==null) left=node;//如果左子结点为空，直接添加
            if(left!=null) left.add(node);//如果不为空则需要挂在子节点的子结点，迭代添加
        }
        if(this.value<node.value)
        {
            if (right==null) right=node;
            if(right!=null) right.add(node);
        }
    }

}

二叉排序树删除结点

删除结点都需要找到待删除的结点和待删除结点的父节点

1，删除叶子结点

2.删除只有一颗子树的结点

3.删除有两个子树的结点

代码实现:

class BTStree{
    private treenode root;

    public treenode getRoot() {
        return root;
    }

    public void setRoot(treenode root) {
        this.root = root;
    }
    //添加结点方法
    public void BTScreat(treenode node){
        if(root==null) root=node;
        else
            root.add(node);
    }
    //前序遍历
    public void  BTSord(){
        if(root==null) return;
        else
            root.ordinpre();
    }
    //二叉排序树删除结点
    //第一种情况:删除叶子结点。
    //寻找要删除的结点
    public treenode targetfindBST(int value)
    {
        if(root==null) return null;
        if(root.getValue()==value) return root;
        else {
           return root.targetsearch(value);
        }
    }
    //寻找要删除结点的父结点
    public treenode parentfindBST(int value)
    {
        //根节点为空或者要删除的结点是根节点时，没有父结点,返回null
        if(root==null||targetfindBST(value)==root) return null;
        else return root.parentfind(value);
    }
    //删除结点函数
    public void delnode(int value){
        if(root==null) return;
        else{
            treenode target=targetfindBST(value);
            treenode parent = parentfindBST(value);
            if(target==null) return;//没找到要删除的结点
            //找到了要删除的结点
           else {
               //删除叶子结点情况
               if(target.getLeft()==null&&target.getRight()==null)
               {
                   //要删除的是根节点
                   if(parent==null){
                       root=null;
                   }
                   else{
                   if(parent.getLeft()!=null&&parent.getLeft()==target)
                       parent.setLeft(null);
                   if(parent.getRight()!=null&&parent.getRight()==target)
                       parent.setRight(null);
                   }
               }
                //删除具有两颗子树的结点
               else if(target.getLeft()!=null&&target.getRight()!=null)
               {
                   int min=delrighttreemin(target.getRight());
                   target.setValue(min);

               }
               //删除只有一颗子树的结点
               else{
                   //删除结点为根结点情况
                   if(parent==null)
                   {
                       if(target.getLeft()!=null) root=target.getLeft();
                       if(target.getRight()!=null) root=target.getRight();
                   }
                   else{
                   //只有左子树的情况
                   if(target.getLeft()!=null)
                   {
                       if(parent.getLeft().getValue()==value)
                           parent.setLeft(target.getLeft());
                       else if(parent.getRight().getValue()==value)
                           parent.setRight(target.getLeft());
                   }
                   //只有右子树的情况
                   if(target.getRight()!=null)
                   {
                       if(parent.getLeft().getValue()==value)
                           parent.setLeft(target.getRight());
                       else if(parent.getRight().getValue()==value)
                           parent.setRight(target.getRight());
                   }
                   }
               }
            }
        }
    }
    public int delrighttreemin(treenode node)
    {
        treenode tem=node;
        //循环的查找左子结点就会找到最小值，根据二叉排序树的特点
        while(tem.getLeft()!=null)
            tem=tem.getLeft();
        delnode(tem.getValue());
        return tem.getValue();
    }


}
class treenode{
    private int value;
    private treenode left;
    private treenode right;

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

    public int getValue() {
        return value;
    }

    public void setValue(int value) {
        this.value = value;
    }

    public treenode getLeft() {
        return left;
    }

    public void setLeft(treenode left) {
        this.left = left;
    }

    public treenode getRight() {
        return right;
    }

    public void setRight(treenode right) {
        this.right = right;
    }
    //结点添加
    public void add(treenode node){
        //本结点值大于添加节点，应放在左子结点
        if(this.value>node.value)
        {
            if (left==null) left=node;//如果左子结点为空，直接添加
            if(left!=null) left.add(node);//如果不为空则需要挂在子节点的子结点，迭代添加
        }
        if(this.value<node.value)
        {
            if (right==null) right=node;
            if(right!=null) right.add(node);
        }
    }
    //前序遍历
    public void ordinpre(){
        System.out.println(this);
        if(left!=null) left.ordinpre();
        if(right!=null) right.ordinpre();
    }
    //寻找要删除的结点

    public treenode targetsearch(int value)
    {

        if(value==this.value) return this;
        //如果本结点值大于查找值，说明在左子树
        else if(value<this.value)
        {
            //如果左子结点为空 说明已经是叶子结点
            if(left==null) return null;
            //否则继续遍历查找
            else  return this.left.targetsearch(value);
        }
       else
        {
            if(right==null) return null;
            else return this.right.targetsearch(value);
        }

    }
    //寻找要删除的结点的父节点
    public treenode parentfind(int value){
        if(left!=null&&left.value==value||right!=null&&right.value==value) return this;
        else if(this.value>value)
        {
            if(left==null) return null;
            else return left.parentfind(value);
        }
        else{
            if(right==null) return null;
            else return right.parentfind(value);
        }
    }

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