二叉排序树的删除节点分析及实现

思路分析

删除叶子结点：

• 需要找到删除的节点node
• 找到node的父节点
• 确定node是左子节点还是右子节点
• 根据前面的情况来对应删除 左：parent.left=null 右：parent.right=null

删除只有一颗子树的节点

• 需要找到删除的节点node
• 找到node的父节点
• 确定node的子节点是左还是右
• 确定node是左还是右
• node是左，若子节点是左：parent.left=node.left 若子节点是右：parent.left=node.right
• node是右，若子节点是左：parent.right=node.left 若子节点是右：parent.right=node.right

删除有两颗子树的结点

• 需要找到删除的节点node
• 找到node的父节点
• 从node右子树中找到最小值并用temp保存
• 删除该最小节点
• node.value=temp

package com.shujujiegou;


import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;

public class ran {

    public static void main(String[] args) {
        int []arr={7,3,10,12,5,1,9,2};
        erchapaixushu erchapaixushu = new erchapaixushu();
        for (int i=0;i<arr.length;i++){
            erchapaixushu.add(new HeroNode(arr[i]));
        }

        erchapaixushu.zhongxu();

        erchapaixushu.shanchu(7);
        System.out.println("删除节点后");
        erchapaixushu.zhongxu();
    }


}
//创建二叉排序树
class erchapaixushu{
    private HeroNode root;

    public HeroNode search(int value){
        if(root==null){
            return null;
        }else {
            return root.search(value);
        }
    }

    public HeroNode fujiedian(int value){
        if(root==null){
            return null;
        }else {
            return root.fujianjie(value);
        }
    }

    public int zuixiaozhi(HeroNode node){
        HeroNode target=node;
        //循环查找最小值
        while (target.zuo!=null){
            target=target.zuo;
        }
        //删除最小节点
        shanchu(target.value);
        return target.value;
    }




    public void shanchu(int value){
        if(root==null){
            return;
        }else {
            HeroNode target=search(value);
            if(target==null){
                return;
            }
            if(root.zuo==null && root.you==null){
                root=null;
                return;
            }

            HeroNode fu=fujiedian(value);
            if(target.zuo==null && target.you==null){
                //判断target是父节点的左子节点还是右子节点
                if(fu.zuo!=null && fu.zuo.value==value){
                    fu.zuo=null;
                }else if(fu.you!=null && fu.you.value==value){
                    fu.you=null;
                }
            }else if(target.zuo!=null && target.you!=null){
                int min=zuixiaozhi(target.you);
                target.value=min;
            }else {
                if(target.zuo!=null){
                    if(fu!=null){
                        if(fu.zuo.value==value){
                            fu.zuo=target.zuo;
                        }else {
                            fu.you=target.zuo;
                        }
                    }else {
                        root=target.zuo;
                    }

                }else {
                    if(fu!=null){
                        if(fu.you.value==value){
                            fu.you=target.you;
                        }else {
                            fu.zuo=target.you;
                        }
                    }else {
                        root=target.you;
                    }

                }
            }
        }
    }






    //添加节点的方法
    public void add(HeroNode heroNode){
        if(root==null){
            root=heroNode;
        }else {
            root.add(heroNode);
        }
    }

    //中序遍历
    public void zhongxu(){
        if (root!=null){
            root.zhongxu();
        }else {
            System.out.println("空");
        }
    }
}



class HeroNode{
    int value;
    HeroNode zuo;
    HeroNode you;

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


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

    public HeroNode search(int value){
        if(value==this.value){
            //就是该节点
            return this;
        }else if(value<this.value){
            if(this.zuo==null){
                return null;
            }
            return this.zuo.search(value);
        }else {
            if(this.you==null){
                return null;
            }
            return this.you.search(value);
        }
    }





    public HeroNode fujianjie(int value){
        if( (this.zuo!=null && this.zuo.value==value) || (this.you!=null&&this.you.value==value)){
            return this;
        }else {
            //如果查找的值小于当前节点的值并且当前节点的左子节点不为空
            if(value<this.value && this.zuo!=null){
                return this.zuo.fujianjie(value);
            }else if(value>=this.value&& this.you!=null){
                return this.you.fujianjie(value);
            }else {
                return null;
            }
        }
    }





    //添加节点
    public void add(HeroNode node){
        //递归的形式添加节点，注意需要满足二叉排序树的要求
        if(node==null){
            return;
        }

        //传入的节点的值，和我们的当前的根节点的值的关系
        if(node.value<this.value){
            if(this.zuo==null){
                this.zuo=node;
            }else {
                this.zuo.add(node);
            }
        }

        if(node.value>=this.value){
            if(this.you==null){
                this.you=node;
            }else {
                this.you.add(node);
            }
        }
    }


    public void zhongxu(){
        if(this.zuo!=null){
            this.zuo.zhongxu();;
        }
        System.out.println(this);
        if(this.you!=null){
            this.you.zhongxu();
        }
    }
}

代码实现效果如下：