数据结构（Java）：揭开二叉搜索树删除机制的奥秘

Sunrise_angel

于 2024-08-19 00:01:32 发布

阅读量416

点赞数 6

分类专栏：数据结构（Java）文章标签：数据结构算法 java 开发语言

本文链接：https://blog.csdn.net/2401_83595513/article/details/141306443

版权

数据结构（Java）专栏收录该内容

18 篇文章 0 订阅

订阅专栏

1.1 概念

2.3.1 要删除节点的左子树为空

2.3.2 要删除节点的右子树为空

2.3.3 要删除节点的左右子树均不为空

2.3.4 删除操作代码

3、整体模拟实现代码

1、二叉搜索树

1.1 概念

二叉搜索树又称二叉排序树，它或者是一棵空树，或者是具有以下性质的二叉树:

若其左子树不为空，则左子树上所有节点的值都小于根节点的值
若其右子树不为空，则右子树上所有节点的值都大于根节点的值
树中每个节点的左右子树也均为二叉搜索树（递归定义）

总结：left.val < root.val < right.val（左子树 < 根节点 < 右子树）

2、代码模拟实现

首先，我们肯定是要在SearchTree类中定义一个内部类TreeNode来表示节点，定义节点时使用左右孩子表示法。

//内部类 -> 定义搜索树的节点
static class TreeNode {
        //左右孩子表示法
        int val;
        TreeNode left;
        TreeNode right;

        public TreeNode(int val) {
            this.val = val;
        }
    }

2.1 插入操作

定义cur和parent指针，根据搜索树左子树 < 根节点 < 右子树的特点，移动cur和parent，找到到新节点插入的位置，插入新节点。

注意：这里parent指针的作用是记录cur父节点的位置，当cur为空即找到要插入的位置时，parent就是新节点node的父节点。

插入操作较为简单，这里不再赘述。

/**
     * 数据插入
     * @param val
     */
    public void insert(int val) {
        TreeNode node = new TreeNode(val);
        if (root == null) {
            root = node;
            return;
        }
        TreeNode cur = root;
        TreeNode parent = null;
        while (cur != null) {
            if (val > cur.val) {
                parent = cur;
                cur = cur.right;
            }else if (val < cur.val) {
                parent = cur;
                cur = cur.left;
            }else {
                //二叉搜索树中节点的值不能重复
                return;
            }
            if (val > parent.val) {
                parent.right = node;
            }else {
                parent.left = node;
            }
        }
    }

2.2 查找操作

查找的思想与插入的思想大致是相同的，只是不用再定义parent了，当找到指定节点时返回即可。

/**
     * 查找数据
     * @param val
     * @return
     */
    public TreeNode searchNode(int val) {
        TreeNode cur = root;
        while (cur != null) {
            if (val > cur.val) {
                cur = cur.right;
            }else if (val < cur.val) {
                cur = cur.left;
            }else {
                return cur;
            }
        }
        return null;
    }

2.3 🌟删除操作🌟（难点）

删除操作是二叉搜索树代码实现时较难的点，因为删除指定节点后需要使树仍为二叉搜索树，所以需要考虑多种情况：

当要删除的节点的左子树不存在时
当要删除的节点的右子树不存在时
当要删除的节点的左右子树均存在时
要删除的节点是否为根节点，是根节点要怎么办，不是根节点要怎么办

当删除节点后，到底要怎样修改节点间的关系使其仍保持为二叉搜索树呢？

在下文的讲解中，cur代表要删除的节点，parent代表当cur的父节点

2.3.1 要删除节点的左子树为空

2.3.2 要删除节点的右子树为空

2.3.3 要删除节点的左右子树均不为空

当要删除节点的左右子树均不为空时，只有这样修改才能使树仍为搜索树：

将cur的值修改为其左子树中的最大值（左树中最右边的节点），再删除最值节点
将cur的值修改为其右子树中的最小值（右树中最左边的节点），再删除最值节点

只有这样，才能在删除完该节点后使树仍为搜索树。

这里需要注意一个特殊情况：

2.3.4 删除操作代码

/**
     * 删除数据
     * @param val
     * @return
     */
    public boolean removeNode(int val) {
        TreeNode cur = root;
        TreeNode parent = null;
        //找到要删除的节点cur和其父节点parent的位置
        while (cur != null) {
            if (val > cur.val) {
                parent = cur;
                cur = cur.right;
            }else if (val < cur.val) {
                parent = cur;
                cur = cur.left;
            }else {
                break;
            }
        }
        //没有该节点
        if (cur == null) {
            return false;
        }
        if (cur != root) {
            //cur不为根节点
            if (cur == parent.right) {
                //cur为父节点的左孩子
                if (cur.left == null) {
                    //cur左树为空
                    parent.right = cur.right;
                }else if (cur.right == null){
                    //cur右树为空
                    parent.right = cur.left;
                }else {
                    //左右都不为空
                    removeSub(cur);
                }
                return true;
            }else {
                //cur为父节点的右孩子
                if (cur.left == null) {
                    //cur左树为空
                    parent.left = cur.right;
                }else if (cur.right == null){
                    //cur右树为空
                    parent.left = cur.left;
                }else {
                    //左右都不为空
                    removeSub(cur);
                }
                return true;
            }
        }else {
            //cur为根节点
            if (cur.left == null) {
                //cur左树为空
                root = cur.right;
            }else if (cur.right == null) {
                //cur右树为空
                root = cur.left;
            }else {
                //左右都不为空
                removeSub(cur);
            }
            return true;
        }
    }

    private void removeSub(TreeNode cur) {
        //将要删除节点的值更改为其左树中值最大的节点（左树中最右边的节点）或者右树中值最小的节点（右树中最左边的节点），并删除这个节点
        //这样可以使其仍满足二叉搜索树的特征：左 < 根 < 右
        //这里更改为左树中的值最大的节点
        TreeNode rParent = cur.left;
        TreeNode right = rParent.right;
        if (right != null) {
            while (right.right != null) {
                rParent = right;
                right = right.right;
            }
            cur.val = right.val;
            rParent.right = right.left;
        }else {
            //当cur的左孩子就是左子树中的最大值时
            cur.val = rParent.val;
            cur.left = rParent.left;
        }
    }

3、整体模拟实现代码

/**
 * Created with IntelliJ IDEA.
 * Description:二叉搜索树的模拟实现
 * User: dings
 * Date: 2024-08-18
 * Time: 23:30
 */
public class SearchTree {
    TreeNode root;
    static class TreeNode {
        //左右孩子表示法
        int val;
        TreeNode left;
        TreeNode right;

        public TreeNode(int val) {
            this.val = val;
        }
    }

    /**
     * 数据插入
     * @param val
     */
    public void insert(int val) {
        TreeNode node = new TreeNode(val);
        if (root == null) {
            root = node;
            return;
        }
        TreeNode cur = root;
        TreeNode parent = null;
        while (cur != null) {
            if (val > cur.val) {
                parent = cur;
                cur = cur.right;
            }else if (val < cur.val) {
                parent = cur;
                cur = cur.left;
            }else {
                //二叉搜索树中节点的值不能重复
                return;
            }
            if (val > parent.val) {
                parent.right = node;
            }else {
                parent.left = node;
            }
        }
    }

    /**
     * 查找数据
     * @param val
     * @return
     */
    public TreeNode searchNode(int val) {
        TreeNode cur = root;
        while (cur != null) {
            if (val > cur.val) {
                cur = cur.right;
            }else if (val < cur.val) {
                cur = cur.left;
            }else {
                return cur;
            }
        }
        return null;
    }

    /**
     * 删除数据
     * @param val
     * @return
     */
    public boolean removeNode(int val) {
        TreeNode cur = root;
        TreeNode parent = null;
        //找到要删除的节点cur和其父节点parent的位置
        while (cur != null) {
            if (val > cur.val) {
                parent = cur;
                cur = cur.right;
            }else if (val < cur.val) {
                parent = cur;
                cur = cur.left;
            }else {
                break;
            }
        }
        //没有该节点
        if (cur == null) {
            return false;
        }
        if (cur != root) {
            //cur不为根节点
            if (cur == parent.right) {
                //cur为父节点的左孩子
                if (cur.left == null) {
                    //cur左树为空
                    parent.right = cur.right;
                }else if (cur.right == null){
                    //cur右树为空
                    parent.right = cur.left;
                }else {
                    //左右都不为空
                    removeSub(cur);
                }
                return true;
            }else {
                //cur为父节点的右孩子
                if (cur.left == null) {
                    //cur左树为空
                    parent.left = cur.right;
                }else if (cur.right == null){
                    //cur右树为空
                    parent.left = cur.left;
                }else {
                    //左右都不为空
                    removeSub(cur);
                }
                return true;
            }
        }else {
            //cur为根节点
            if (cur.left == null) {
                //cur左树为空
                root = cur.right;
            }else if (cur.right == null) {
                //cur右树为空
                root = cur.left;
            }else {
                //左右都不为空
                removeSub(cur);
            }
            return true;
        }
    }

    private void removeSub(TreeNode cur) {
        //将要删除节点的值更改为其左树中值最大的节点（左树中最右边的节点）或者右树中值最小的节点（右树中最左边的节点），并删除这个节点
        //这样可以使其仍满足二叉搜索树的特征：左 < 根 < 右
        //这里更改为左树中的值最大的节点
        TreeNode rParent = cur.left;
        TreeNode right = rParent.right;
        if (right != null) {
            while (right.right != null) {
                rParent = right;
                right = right.right;
            }
            cur.val = right.val;
            rParent.right = right.left;
        }else {
            //当cur的左孩子就是左子树中的最大值时
            cur.val = rParent.val;
            cur.left = rParent.left;
        }
    }
}

END