【DS】二叉搜索树的介绍和实现

女爷i 2023-09-25 12:17 21阅读 0赞

![在这里插入图片描述][3f9026f5c260455c8ecd6dfef03f83ed.gif_pic_center]

✨**博客主页:**[ **心荣~**][Link 1]  
✨**系列专栏:**[**【Java实现数据结构】**][Java]  
✨**一句短话:** **难在坚持,贵在坚持,成在坚持!**

#### 文章目录 ####

*  一. 什么是二叉搜索树
 *  二. 简单实现一下搜索树
 *   *  1. 节点结构
     *  2. 查找操作
     *  3. 插入操作
     *  4. 删除操作
     *  5. 修改操作
 *  三. 性能分析

## 一. 什么是二叉搜索树 ##

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

*  若它的左子树不为空，则左子树上所有节点的值都小于根节点的值
 *  若它的右子树不为空，则右子树上所有节点的值都大于根节点的值
 *  它的左右子树也分别为二叉搜索树
 *  中序遍历二叉搜索树，得到的序列是依次递增的
 *  二叉搜索树的结点的值不能发生重复

int a \[\] = \{5,3,4,1,7,8,2,6,0,9\};

![img][]

## 二. 简单实现一下搜索树 ##

### 1. 节点结构 ###

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

### 2. 查找操作 ###

二叉搜索树的存在就是为了方便查找的，根据二叉搜索树的特点，左子树的元素比根小，右子树的元素比根大，所以我们需要根据根节点的值与目标元素的值比较去实现查找

*  根与目标元素相等，表示找到了;
 *  目标元素比根小，去左子树找;
 *  目标元素比根大，去右子树找;
 *  左右子树都找不到，则树中不存在要找的元素

![img][img 1]

代码实现:

//查找元素
        public TreeNode search(int key) {
        
            TreeNode cur = root;
            while(cur != null) {
        
                if(key < cur.val) {
        
                    cur = cur.left;
                }else if(key > cur.val) {
        
                    cur = cur.right;
                }else{
        
                    return cur;
                }
            }
            return null;
        }

### 3. 插入操作 ###

想要在二叉搜索树中插入一个元素，那么就得找到一个可以的插入位置，我们可以利用二叉树的搜索方式去找到一个合适的空位置进行插入;

1.  如果树为空树，即根 == null，直接插入

![img][img 2]

1.  如果树不是空树，按照查找逻辑确定插入位置，插入新结点

*  根与插入元素相等，树中已经有了这个元素了, 不能重复插入;
 *  根比插入元素大，去左子树找;
 *  根比插入元素小，去右子树找;
 *  找到的结点为空，那这个位置就是我们要找的空位。

![img][img 3]

代码实现:

//插入元素
        public boolean insert (int key) {
        
            if(root == null) {
        
                root = new TreeNode(key);
                return true;
            }
            TreeNode parent = null;
            TreeNode cur = root;
            while(cur != null) {
        
                if(key < cur.val) {
        
                    parent = cur;
                    cur = cur.left;
                }else if(key > cur.val) {
        
                    parent = cur;
                    cur = cur.right;
                }else{
        
                    return false;//树中不能有重复的元素
                }
            }
            TreeNode node = new TreeNode(key);
            if(key < parent.val) {
        
                parent.left = node;
            }else{
        
                parent.right = node;
            }
            return true;
        }

### 4. 删除操作 ###

删除情况主要是下面三种场景下的删除, 具体分析如下:

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

1.  cur.left == null

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

1.  cur.right == null

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

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

*  可以使用替换法(替罪羊法)进行删除，即在它的右子树中寻找值最小的节点，用它的值填补到被删除节点中，再将这个最小值节点删除即可, 右子树节点的最小值节点的右子树一定是为空的, 所以此时的删除操作又和上面的2类似了; 同样的,也可以采用去找要删除节点左子树的最大值来实现;
 *  最容易忽略的一点是, 找要删除节点的右子树的最小值为例, 如果右子树节点中没有左子树只有右子树; 此时与上面的情况就不相同了

![img][img 4]

![img][img 5]

//删除元素
        public void romove(int key) {
        
            TreeNode parent = null;
            TreeNode cur = root;
            while(cur != null) {
        
                if(key < cur.val) {
        
                    parent = cur;
                    cur = cur.left;
                }else if(key > cur.val) {
        
                    parent = cur;
                    cur = cur.right;
                }else{
        
                    romoveNode(parent, cur);
                    return true;
                }
            } 
            return false;
        }
        private void romoveNode(TreeNode parent, TreeNode cur) {
        
            if(cur.left == null) {
        
                if(cur == root) {
        
                    root = cur.right;
                }else if(cur == parent.left) {
        
                    parent.left = cur.right;
                }else if(cur == parent.right){
        
                    parent.right = cur.right;
                }
            }else if(cur.right == null) {
        
                if(cur == root) {
        
                    root = cur.left;
                }else if(cur == parent.left) {
        
                    parent.left = cur.left;
                }else if(cur == parent.right){
        
                    parent.right = cur.left;
                }
            }else {
        
                TreeNode target = cur.right;
                TreeNode targetParent = cur;
                while(target.left != null) {
        
                    targetParent = target;
                    target = target.left;
                }
                cur.val = target.val;
                if(target == targetParent.left) {
        
                    targetParent.left = target.right;
                }else {
        //要删除的节点右边只有一个节点
                    targetParent.right = target.right;
                }
            }
        }

### 5. 修改操作 ###

搜索树的修改可以基于删除和插入操作来实现，先将目标元素删除(确定有删除的元素才能有插入操作)，然后再插入修改元素(不能重复插入)。

//修改元素
        public void set(int key, int val){
        
            if(romove(key)) {
        
                insert(val);
            }
        }

## 三. 性能分析 ##

插入和删除操作都必须先查找，查找效率代表了二叉搜索树中各个操作的性能。

对有n个结点的二叉搜索树，若每个元素查找的概率相等，则二叉搜索树平均查找长度是结点在二叉搜索树的深度，即结点越深，则比较次数越多。

但对于同一个关键码集合，如果各关键码插入的次序不同，可能得到不同结构的二叉搜索树：

![img][img 6]

最优情况下，二叉搜索树为完全二叉树，时间复杂度为: O(logN)

最差情况下，二叉搜索树退化为单支树，其平均比较次数为: O(N)

[3f9026f5c260455c8ecd6dfef03f83ed.gif_pic_center]: https://img-blog.csdnimg.cn/3f9026f5c260455c8ecd6dfef03f83ed.gif#pic_center
[Link 1]: https://blog.csdn.net/Trong_?spm=1000.2115.3001.5343
[Java]: https://blog.csdn.net/trong_/category_11997769.html
[img]: https://img-blog.csdnimg.cn/img_convert/e7c6bc0fcd939304a8da067eb9d8c67e.png
[img 1]: https://img-blog.csdnimg.cn/img_convert/74ea3f53cebdcc3509b00f921d8e1948.png
[img 2]: https://img-blog.csdnimg.cn/img_convert/4e999b9341c69fe41ffce94d309a8e9b.png
[img 3]: https://img-blog.csdnimg.cn/img_convert/4e358532860db7e310f005683930ebe0.png
[img 4]: https://img-blog.csdnimg.cn/img_convert/e67a4187887dadd540ddeb3f2ed1b94c.png
[img 5]: https://img-blog.csdnimg.cn/img_convert/8be2bf23ef42f64651d692dabf28f4dd.png
[img 6]: https://img-blog.csdnimg.cn/img_convert/48ebeaf3de7c7edba7fd1e3585bd6475.png