Map&Set之二叉搜索树

已于 2024-09-08 19:31:19 修改
阅读量871 收藏 22
点赞数 33
分类专栏： 数据结构 文章标签： 散列表 算法 数据结构
于 2024-09-07 20:00:00 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_62055442/article/details/141098726
版权

  系列文章：

                 1.   先导片--Map&Set之二叉搜索树

                 2.   Map&Set之相关概念

                 3.   哈希表如何避免冲突

目录

前言

1.二叉搜索树

1.1 定义

1.2 操作-查找

1.3 操作-新增

1.4 操作-删除(难点)

1.5 总体实现代码

1.6 性能分析

前言

      TreeMap 和 TreeSet 是 Java 中基于搜索树实现的 Map 和 Set。实际上，它们使用的是红黑树数据结构，而红黑树是一种近似平衡的二叉搜索树。在红黑树的基础上，还添加了颜色属性以及红黑树性质验证来确保树的平衡性，所以我们需要了解一下二叉搜索树这个概念。

1.二叉搜索树

1.1 定义

二叉搜索树又称二叉排序树，它或者是一棵空树，或者是具有以下性质的二叉树 :
若它的左子树不为空，则左子树上所有节点的值都小于根节点的值
若它的右子树不为空，则右子树上所有节点的值都大于根节点的值
它的左右子树也分别为二叉搜索树

1.2 操作-查找

如果根节点不为空：

如果根节点key == 查看key 返回true

如果根节点key > 查看key 在其左子树查找

如果根节点key < 查看key 在其右子树查找

否则返回false

实现代码：

class BinarySearchTree {
    public static class Node {
        int key;
        Node left;
        Node right;

        public Node(int key) {
            this.key = key;
        }
    }

    private Node root = null;

    /**
     * 搜索
     * @param key
     * @return
     */
    public Node search(int key) {
        Node cur = root;
        while (cur != null){
            if(cur.key == key){
                return cur;
            }else if (key < cur.key){
                cur = cur.left;
            }else{
                cur = cur.right;
            }
        }
        return null;
    }
}

1.3 操作-新增

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

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

实现代码：

class BinarySearchTree {
    public static class Node {
        int key;
        Node left;
        Node right;

        public Node(int key) {
            this.key = key;
        }
    }

    private Node root = null;

    /**
     * 插入
     *
     * @param key
     * @return
     */
    public boolean insert(int key) {
        Node cur = root;
        if (cur == null) {
            cur = new Node(key);
            return true;
        }
        Node parent = null;
        while (cur != null) {
            if (key == cur.key) {
                return false;
            } else if (key < cur.key) {
                parent = cur;
                cur = cur.left;
            } else {
                parent = cur;
                cur = cur.right;
            }
        }
        Node node = new Node(key);
        if (key < parent.key) {
            parent.right = node;
        } else {
            parent.left = node;
        }
        return true;
    }
}

1.4 操作-删除(难点)

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

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；

需要使用替换法进行删除，即在它的右子树中寻找中序下的第一个结点(关键码最小)，用它的值填补到被删除节点中，再来处理该结点的删除问题。

实现代码：

class BinarySearchTree {
    public static class Node {
        int key;
        Node left;
        Node right;

        public Node(int key) {
            this.key = key;
        }
    }

    private Node root = null;


    /**
     * 删除
     *
     * @param key
     * @return
     */
    public boolean delete(int key) {
        Node cur = root;
        Node parent = null;
        while (cur != null) {
            if (key == cur.key) {
                deleteValue(cur, parent);
                return true;
            } else if (key < cur.key) {
                parent = cur;
                cur = cur.left;
            } else {
                parent = cur;
                cur = cur.right;
            }
        }
        return false;
    }

    public void deleteValue(Node cur, Node parent) {
        //cur左右孩子都不在
        if (cur.left == null && cur.right == null) {
            if (parent.right == cur) {
                parent.right = null;
            } else {
                parent.left = null;
            }
            //cur左孩子不在
        }else if (cur.left == null) {
            if (cur == root) {
                root = root.right;
            } else if (cur == parent.right) {
                parent.right = cur.right;
            } else {
                parent.left = cur.right;
            }
            //cur右孩子不在
        }else if (cur.right == null) {
            if (cur == root) {
                root = root.left;
            } else if (cur == parent.right) {
                parent.right = cur.left;
            } else {
                parent.left = cur.left;
            }
            //左右均在
        }else{
            //为删除节点的右节点
            Node target = cur.right;
            Node targetParent = cur;
            //找右树最左节点
            while (target.left != null){
                targetParent = target;
                target = target.left;
            }
            cur.key = target.key;
            if(targetParent.left == target){
                targetParent.left = target.right;
            }else{
                targetParent.right = target.right;
            }
        }
    }
}

1.5 总体实现代码

class BinarySearchTree {
    public static class Node {
        int key;
        Node left;
        Node right;

        public Node(int key) {
            this.key = key;
        }
    }

    private Node root = null;

    /**
     * 搜索
     *
     * @param key
     * @return
     */
    public Node search(int key) {
        Node cur = root;
        while (cur != null) {
            if (cur.key == key) {
                return cur;
            } else if (key < cur.key) {
                cur = cur.left;
            } else {
                cur = cur.right;
            }
        }
        return null;
    }

    /**
     * 插入
     *
     * @param key
     * @return
     */
    public boolean insert(int key) {
        Node cur = root;
        if (cur == null) {
            cur = new Node(key);
            return true;
        }
        Node parent = null;
        while (cur != null) {
            if (key == cur.key) {
                return false;
            } else if (key < cur.key) {
                parent = cur;
                cur = cur.left;
            } else {
                parent = cur;
                cur = cur.right;
            }
        }
        Node node = new Node(key);
        if (key < parent.key) {
            parent.right = node;
        } else {
            parent.left = node;
        }
        return true;
    }

    /**
     * 删除
     *
     * @param key
     * @return
     */
    public boolean delete(int key) {
        Node cur = root;
        Node parent = null;
        while (cur != null) {
            if (key == cur.key) {
                deleteValue(cur, parent);
                return true;
            } else if (key < cur.key) {
                parent = cur;
                cur = cur.left;
            } else {
                parent = cur;
                cur = cur.right;
            }
        }
        return false;
    }

    public void deleteValue(Node cur, Node parent) {
        //cur左右孩子都不在
        if (cur.left == null && cur.right == null) {
            if (parent.right == cur) {
                parent.right = null;
            } else {
                parent.left = null;
            }
            //cur左孩子不在
        }else if (cur.left == null) {
            if (cur == root) {
                root = root.right;
            } else if (cur == parent.right) {
                parent.right = cur.right;
            } else {
                parent.left = cur.right;
            }
            //cur右孩子不在
        }else if (cur.right == null) {
            if (cur == root) {
                root = root.left;
            } else if (cur == parent.right) {
                parent.right = cur.left;
            } else {
                parent.left = cur.left;
            }
            //左右均在
        }else{
            //为删除节点的右节点
            Node target = cur.right;
            Node targetParent = cur;
            //找右树最左节点
            while (target.left != null){
                targetParent = target;
                target = target.left;
            }
            cur.key = target.key;
            if(targetParent.left == target){
                targetParent.left = target.right;
            }else{
                targetParent.right = target.right;
            }
        }
    }
}

1.6 性能分析

      在二叉搜索树中，插入和删除操作都需要先进行查找。查找的效率直接影响了这些操作的性能。对于一个有n个节点的二叉搜索树，如果每个元素被查找的概率相等，那么平均查找长度将取决于节点在二叉搜索树中的深度。换句话说，节点越深，需要进行的比较次数就越多。

     然而，对于相同的关键码集合，如果插入关键码的顺序不同，可能会得到不同结构的二叉搜索树。这是因为二叉搜索树的性质要求左子树的所有节点的值小于根节点的值，右子树的所有节点的值大于根节点的值。因此，不同的插入顺序可能会导致树的结构有所不同，从而影响查找效率。

最优情况下，二叉搜索树为完全二叉树，其平均比较次数为：log(N）

最差情况下，二叉搜索树退化为单支树，其平均比较次数为：N/2

Petrichor-瑾
关注
专栏目录
Leetcode数据结构&算法：二叉搜索树
yfy1127yfy的博客
11-18 248
一、介绍 二叉搜索树（BST）是二叉树的一种特殊表示形式，它满足如下特性： 每个节点中的值必须大于（或等于）存储在其左侧子树中的任何值。 每个节点中的值必须小于（或等于）存储在其右子树中的任何值。 像普通的二叉树一样，我们可以按照前序、中序和后序来遍历一个二叉搜索树。 但是值得注意的是，对于二叉搜索树，我们可以通过中序遍历得到一个递增的有序序列。因此，中序遍历是二叉搜索树中最常用的遍历...
【数据结构】二叉搜索树与Map和Set
qq_61872165的博客
09-22 258
因此，为了保证每个节点的左右子树高度相差不超过1，这才有了AVL树（通过左旋，右旋，左右双旋调整高度差），而为了减少AVL的旋转次数，这才有了红黑树（通过染色来保证平衡，不需要每次都调整，复杂度相对较低）。③.由于二叉搜索树左子树的节点值小于根节点，右子树的节点值大于根节点，故二叉搜索树还支持范围查询。的容器或者数据结构，它适合多态查找（查找时能进行一些插入和删除的操作），其搜索的效率与其具体的实例化子类有关。个结点的二叉搜索树，若每个元素查找的概率相等，则二叉搜索树的高度越高，查找效率越低。
【C++进阶】二叉搜索树特性 && 二叉搜索树模拟实现
2301_78611726的博客
05-02 971
我们之前在c语言部分数据结构初阶就已经讲过二叉树了，为什么那时我们不讲二叉搜索树呢？这是有原因的，这里讲二叉树进阶是因为：1.map与set特性需要先铺垫二叉搜索树的概念，理解了二叉搜索树可以更好的理解map与set2.当时用c语言讲二叉树时没有将进阶，是因为这部分较难，长时间下容易忘记。3.一些OJ题更适合用c++解决，当时用c语言会比较麻烦，需要动态开辟数组等。因此有了进阶二叉树部分，是对我们的二叉树进行的收尾总结。
HashMap以及二叉搜索树(Map和Set)
Cheer_RIO的博客
07-25 454
HashMap，TreeSet，哈希值，哈希冲突，负载因子调节
【C++】二叉搜索树
春风不语。
10-01 1031
本篇到这里就结束了，主要讲了二叉搜索树的基本概念以及实现逻辑，希望对大家有所帮助，祝生活愉快，我们下篇再见！
一文带你了解Map和Set、二叉搜索树
weixin_54342360的博客
04-08 901
重点介绍Set和Map的一些常用方法，以及二叉搜索树的基本操作的实现。
数据结构八：二叉搜索树，Map，Set，哈希
qq_56701924的博客
11-12 1983
Map和Set的知识点和习题二插搜索树的模拟实现。hashcode()和equals（）的区别
【数据结构】二叉搜索树（Java + 链表实现）
明志の博客
08-07 1154
Map接口是独立的实现Iterable接口的集合都是可以使用 for - Each 语句进行打印的搜索性能会非常高。
java二叉搜索树、Map、Set详解用法和区别
Original0的博客
10-22 705
1. **Map是一个接口，不能直接实例化对象，如果要实例化对象只能通过实例化实现类TreeMap或HashMap。** 2. **HashMap** ：存储数据采用哈希表结构，元素的存取顺序不能保证一致，**K的类型一定要可以比较，由于要保证K的唯一，不重复，需要重写HashCode()、equals()方法。** 3. 使用put方法时，如传的key存在，则只会把指定key所对应的value值，替换成指定的新值，而不会再添加一个key，返回值为key对应的value值。 4. 使用ge
二叉排序树与 set、map
WANGHAOXIN364的博客
03-26 1505
前置知识：二叉树的概念及性质 为了保证学习效果，请保证已经掌握前置知识之后，再来学习本章节！ 学习目标 理解二叉排序树的概念 理解二叉排序树的查找、插入、删除、构建和简单平衡的过程 掌握 STL 的容器map、set的使用方法及其用途 二叉排序树的概念 二叉排序树（Binary Sort Tree），又称二叉查找树（Binary Search Tree）、二叉搜索树，是指一棵空树，或者是具有下列性质的二叉树： 若它的左子树不空，则左子树上所有结点的值均小于它的根结点的值。 若它的右...
【二叉树进阶】AVLTree - 平衡二叉搜索树
codewinter的博客
06-20 2725
二叉搜索树的插入和删除操作都必须先查找，查找效率代表了二叉搜索树中各个操作的效率。但是二叉搜索树有其自身的缺陷，假如往树中插入的元素有序或者接近有序，二叉搜索树就会退化成单支树，时间复杂度为O(N)，因此 map、set 等关联式容器的底层结构是对二叉树进行了平衡处理，即采用平衡二叉搜索树来实现。最优情况下，有 n 个结点的二叉搜索树为完全二叉树，查找效率为：O(log2N)最差情况下，有 n 个结点的二叉搜索树退化为单支树，查找效率为：O(N)平衡二叉搜索树（Self-balancing binary s
二叉搜索树及中序遍历
繁华街角的歇脚处
03-30 5213
二叉搜索树的概念 二叉搜索树（Binary Search Tree），（又：二叉搜索树，二叉排序树）它或者是一棵空树，或者是具有下列性质的二叉树： 若它的左子树不空，则左子树上所有结点的值均小于它的根节点的值； 若它的右子树不空，则右子树上所有结点的值均大于它的根结点的值； 它的左、右子树也分别为二叉排序树。二叉搜索树作为一种经典的数据结构，它既有链表的快速插入与删除操作的特点，又有数组快速查找的优势；所以应用十分广泛，例如在文件系统和数据库系统一般会采用这种数据结构进行高效率的排序与检索操作。 图..
【二叉树进阶】红黑树（Red Black Tree） - 平衡二叉搜索树
codewinter的博客
06-21 3348
红黑树，是一种平衡二叉搜索树，但在每个结点上增加一个存储位表示结点的颜色，可以是 Red 或 Black。通过对任何一条从根到叶子的路径上各个结点着色方式的限制，红黑树确保没有一条路径会比其他路径长出2倍，因而是接近平衡的。AVL树和红黑树：红黑树更多是一种折中的选择，它舍弃平衡二叉树的严格平衡，换取节点插入时尽可能少的调整。因为红黑树的旋转情况少于AVL树，使得红黑树整体性能略优于AVL树，不然map和set底层怎么会用红黑树呢，包括很多语言的库里面都用了红黑树。如果发明AVL树的人是天才的话，那么发明红
二叉搜索树
weixin_45926367的博客
05-15 615
二叉搜索树 二叉搜索树是二叉树的一种特殊形式。 二叉搜索树具有以下性质：每个节点中的值必须大于（或等于）其左侧子树中的任何值，但小于（或等于）其右侧子树中的任何值。 二叉搜索树的定义 二叉搜索树（BST）是二叉树的一种特殊表示形式，它满足如下特性： 每个节点中的值必须大于（或等于）存储在其左侧子树中的任何值。 每个节点中的值必须小于（或等于）存储在其右子树中的任何值。 下面是一个二叉搜索树的例子： 这篇文章之后，我们提供了一个习题来让你验证一个树是否是二叉搜索树。 你可以运用我们上述提到的性质来判断
打卡第四天 P1081 [NOIP2012 提高组] 开车旅行
hjxxlsx的博客
10-06 442
【代码】打卡第四天 P1081 [NOIP2012 提高组] 开车旅行。
代码随想录算法训练营Day28 | 39. 组合总和、40.组合总和Ⅱ、131.分割回文串
jiabao0520的博客
10-08 1291
训练营第28天：39. 组合总和、40.组合总和Ⅱ、131.分割回文串
c语言练习题2(字符串和函数的使用)
最新发布
m0_74859128的博客
10-10 210
回文函数用于判断一个给定的字符串是否为回文。输入是一个字符数组（字符串），输出是一个布尔值，表示该字符串是否为回文。编写一个 C 语言程序，计算两个整数在二进制表示中有多少位不同。2. 比较这两个整数在二进制表示中的每一位（共32位）是否不同。1. 提示用户输入两个整数。3. 统计不同的位的数量。4. 输出不同的位数。
ICPC-day2(圆方树)
m0_74315028的博客
10-08 275
每次询问两点x, y，求是否存在一个n的排列，使得第一个元素为x，最后一个元素为y，且排列的任意一个前缀、任意一个后缀都连通。可以用圆方树缩点将其变成一颗树，再判断这颗树是否是一条链，x,y是否在这条链的两侧。其实就是求这两个点是否存在两个不相同的路径，同时两者路径的交集是n。
C++STL 二叉搜索树
09-06
C++ STL中没有直接提供二叉搜索树的实现，但STL中有一些关于树的容器，比如set和map，它们底层的实现就是基于红黑树（一种平衡二叉搜索树）的。你可以使用这些容器来实现二叉搜索树的功能。关于二叉搜索树的一些知识，比如二叉树的遍历、迭代、线索二叉树、堆、Huffman编码、AVL树等都可以在STL中找到相应的实现。 二叉搜索树的查找可以通过比较根节点的值和目标值的大小来判断是往左子树还是往右子树查找，并重复这个过程直到找到目标值或者遍历到叶子节点为止。常规实现使用循环来实现查找，递归实现使用递归函数来查找。 二叉搜索树的插入操作也可以通过递归或循环来实现，根据目标值和当前节点的值的大小关系来决定是往左子树还是往右子树插入新节点。 STL中的二叉搜索树容器如set和map提供了插入、删除和查找等功能，并且保持了二叉搜索树的性质。你可以使用这些容器来处理二叉搜索树相关的操作。<span class="em">1</span><span class="em">2</span><span class="em">3</span> #### 引用[.reference_title] - *1* [C++ STL 数据结构 树](https://download.csdn.net/download/xinxipan/3008948)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v93^chatsearchT3_1"}}] [.reference_item style="max-width: 50%"] - *2* *3* [【C++ STL】-- 二叉搜索树](https://blog.csdn.net/weixin_64609308/article/details/128018280)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v93^chatsearchT3_1"}}] [.reference_item style="max-width: 50%"] [ .reference_list ]
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值