二叉搜索树【Java数据结构】

原创已于 2022-11-03 22:21:55 修改 · 641 阅读

8 ·

CC 4.0 BY-SA版权

文章标签：

#数据结构 #java #算法 #开发语言

于 2022-11-03 22:20:24 首次发布

数据结构专栏收录该内容

9 篇文章

订阅专栏

本文详细介绍了二叉搜索树的基本概念、查找、插入和删除操作，并提供了完整的代码实现。通过本文，读者可以全面了解二叉搜索树的工作原理及其实现细节。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

搜索树

1.概念

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

若它的左子树不为空，则左子树上所有节点的值都小于根节点的值

若它的右子树不为空，则右子树上所有节点的值都大于根节点的值

它的左右子树也分别为二叉搜索树

2. 操作-查找

查找规律：

若根节点不为空：

如果根节点val = 查找val，返回true

如果根节点val > 查找val，从该节点左子树查找

如果根节点val < 查找val，从该节点右子树查找

若最后根节点为空，返回false

3. 操作-插入

1.如果树为空树，即根为null，就可以直接插入。

2.如果树非空树，应按照查找逻辑找到插入位置，插入新节点。

通过查找的规则来寻找插入节点，每次插入的节点都为叶子节点！

注意相同的key是不可以插入的！

从根节点开始，根据查找的规则用cur进行节点遍历，同时用prev来存储遍历的前一个节点，直到cur == null时，此时prev已经遍历到叶子节点，再进行判断key与该叶子节点的大小关系来决定放在left还是right。

4. 操作-删除

设待删除结点为 cur, 待删除结点的双亲结点为 parent

分为三种情况：

1. cur.left == null

2. cur.right == null

3. cur.left != null && cur.right != null

1. cur.left == null

1. cur 是 root，则 root = cur.right

2. cur 不是 root，cur 是 parent.left，则 parent.left = cur.right

3. cur 不是 root，cur 是 parent.right，则 parent.right = cur.right

2. cur.right == null

1. cur 是 root，则 root = cur.left

2. cur 不是 root，cur 是 parent.left，则 parent.left = cur.left

3. cur 不是 root，cur 是 parent.right，则 parent.right = cur.left

3. cur.left != null && cur.right != null

对于这一种情况，我们采用替罪羊的方式进行删除，即寻找要删除节点的左子树的最右端的一个节点，该节点的val为左子树的最大值，同时也满足小于要删除节点的右子树的所有节点，用该值填补到被删除节点，所以问题就转变为：处理这个替换节点原位置的删除问题了。而这个替换节点作为左子树的最右端，它的 right 为 null ，所以就是上述cur.right == null这一种情况了，问题也就迎刃而解了。

或者寻找要删除节点的右子树的最左端的一个节点(中序下的第一个结点)，该节点的val为右子树的最小值，同时也满足大于要删除节点的左子树的所有节点。用该值填补到被被删除节点，再处理这个替换节点原位置的删除问题了。这个替换节点作为右子树的最左端，它的 left 为 null ，也就是上述cur.left == null这一种情况了。

如删除上图的cur，可以采用以下两种方式。

易错点！！！

此时，还有一种特殊情况需要注意，以右树最左节点为例：tmp=cur.right

在上述的讨论情况中，到最后删除替换节点原位置这一阶段时，我们采用parent.left = tmp.right的方法，如下图情况一。

但此时我们忽略了另一种情况：一开始的接收到的tmp就已经是右子树的最左端了，如下图情况二。此时要删除替换节点原位置的时候，就不可以再用parent.left = tmp.right这条语句了！！！而应该用parent.right = tmp.right。

所以再完成代码的时候应该添加判断语句parent.right == tmp，成立实现情况二，不成立实现情况一。（结合下面代码分析效果更佳）

5. 代码实现

class BinarySearchTree{
    static class TreeNode{
        public int val;
        public TreeNode left;
        public TreeNode right;
        public TreeNode(int val){
            this.val = val;
        }
    }

    public TreeNode root = null;

    /**
    * 查找一个val 是不是在当前的搜索树当中
    * @param val
    * @return 有返回 没有返回null
    */
    public boolean search(int val){
        TreeNode cur = root;
        while (cur != null){
            if (cur.val<val){
                cur = cur.right;
            } else if (cur.val>val) {
                cur = cur.left;
            }else{
                return true;
            }
        }
        return false;
    }


    //中序遍历
    public void inorder(TreeNode root){
        if (root == null){
            return;
        }
        inorder(root.left);
        System.out.print(root.val+" ");
        inorder(root.right);
    }
    /**
     * 插入元素key
     * @param key
     * @return
     * 每次插入都是插入在叶子结点!!!!
     */
    public boolean insert(int key){
        if (root == null){
            root = new TreeNode(key);
            return true;
        }
        TreeNode cur = root;
        TreeNode prev = null;
        while (cur!=null){
            if (cur.val>key){
                prev = cur;
                cur = cur.left;
            }else if (cur.val<key){
                prev = cur;
                cur = cur.right;
            }else {
                return false;   //相同的key是不能进行插入的
            }
        }
        //cur = null 了
        //判断key大于prev还是小于prev来判断在左边还是右边

        TreeNode newNode = new TreeNode(key);
        if (key> prev.val){
            prev.right = newNode;
        }else{
            prev.left = newNode;
        }
        return true;
    }

    public void remove(int key){
        TreeNode cur = root;
        TreeNode prev = null;
        while (cur!=null){
            if (key> cur.val){
                prev = cur;
                cur = cur.right;
            } else if (key< cur.val) {
                prev = cur;
                cur = cur.left;
            }else {
                removeNode(cur,prev);
                return;
            }
        }

    }

    public void removeNode(TreeNode cur,TreeNode prev){
        if (cur.left == null){                  //该节点左边为null
            if (cur == root){                   //该节点为根结点
                root = cur.right;
            } else if (cur == prev.left) {      //该节点为prev的左边
                prev.left = cur.right;
            }else {                             //该节点为prev的右边
                prev.right = cur.right;
            }
        } else if (cur.right == null) {         //该节点右边为null
            if (cur == root){
                root = cur.left;
            } else if (cur == prev.left) {
                prev.left = cur.left;
            }else {
                prev.right = cur.left;
            }
        }else{                                  //该节点左右两边都不为null
            TreeNode tmp = cur.right;       //找到左树最右节点或者右树最左节点来作为删除节点的值，然后操作删除左树最右节点或者右树最左节点。一般以右树最左节点来计算
            TreeNode tmpParent = cur;
            while (tmp.left!=null){
                tmpParent = tmp;
                tmp = tmp.left;             //找到右树最左节点后，剩下的操作就是将该节点值赋给删除的节点，然后操作删除右树的最左节点
            }
            cur.val = tmp.val;
            if (tmpParent.right == tmp){
                tmpParent.right = tmp.right;              //一开始的tmp就已经是右树最左端了！！！
            }else {
                tmpParent.left = tmp.right;                 //非一开始的tmp就已经是右树最左端了！！！
            }

        }
    }


}