二叉搜索树-map/set的底层容器（C++实现）

最新推荐文章于 2024-04-21 06:32:24 发布
最新推荐文章于 2024-04-21 06:32:24 发布
阅读量399 收藏 2
点赞数
分类专栏： 二叉搜索树 文章标签： 算法 二叉树
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u010323563/article/details/111245240
版权

为了聚焦于二叉搜索树算法的实现，没有采用模板支持不同数据类型，(key, value)均采用 int 数值。

二叉搜索树节点和树定义

    // 二叉树节点，(key, value) 为 (int, int)
    struct Node {
        int key = 0;
        int value = 0;
        Node *left = nullptr;
        Node *right = nullptr;

//        Node() : key(0), value(0), left(nullptr), right(nullptr) {}

        Node(int k, int v) : key(k), value(v), left(nullptr), right(nullptr) {}

        Node(Node *rhs) : key(rhs->key), value(rhs->value), left(rhs->left), right(rhs->right) {}

//        Node(int k, int v, Node *left, Node *right) : key(k), value(v), left(left), right(right) {}
    };

    // 二叉搜索树
    class BST {
    public:
        BST() : root(nullptr), count(0) {}

//        BST(Node *p, int size) : root(p), count(size) {}

        ~BST() { destory(root); }

        int size() { return count; }

        bool isEmpty() { return count == 0; }

        void insert(int k, int v);

        Node *search(int k);

        bool contain(int k);

        // 深度遍历
        void preOrder();

        void inOrder();

        void postOrder();

        // 广度遍历
        void levelOrder();

        // 最大最小值
        int maxinum();

        int mininum();

        void removeMax();

        void removeMin();

        // 删除任意节点
        void removeNode(int key);

        // floor/ceil
        Node *floor(int key);

        Node *ceil(int key);

        // 前驱/后继
        Node *predecessor(int key);

        Node *successor(int key);

    private:
        void destory(Node *p);

        Node *predecessorFromAncestor(Node *p, int key);

        Node *successorFromAncestor(Node *p, int key);

        Node *floor(Node *p, int key);

        Node *ceil(Node *p, int key);

        Node *removeNode(Node *p, int key);

        Node *maxinum(Node *p);

        Node *mininum(Node *p);

        Node *removeMax(Node *p);

        Node *removeMin(Node *p);

        Node *insert(Node *p, int k, int v);

        Node *search(Node *p, int k);

        bool contain(Node *p, int k);

        void preOrder(Node *p);

        void inOrder(Node *p);

        void postOrder(Node *p);

        void levelOrder(Node *p);


        Node *root = nullptr;
        int count = 0;
    };

插入

   void BST::insert(int k, int v) {
        root = insert(root, k, v);
    }

    Node *BST::insert(Node *node, int k, int v) {
        if (node == nullptr) {
            ++count;  // attention
            return new Node(k, v);
        }

        if (k < node->key) {
            node->left = insert(node->left, k, v);
        } else if (k > node->key) {
            node->right = insert(node->right, k, v);
        } else {
            node->value = v;
        }
        return node;
    }

查找/是否包含

    bool BST::contain(int k) {
        return contain(root, k);
    }

    bool BST::contain(Node *p, int k) {
        if (p == nullptr) {
            return false;
        }
        if (k == p->key) {
            return true;
        } else if (k < p->key) {
            return contain(p->left, k);
        } else {
            return contain(p->right, k);
        }
    }

    Node *BST::search(int k) {
        return search(root, k);
    }

    Node *BST::search(Node *p, int k) {
        if (p == nullptr) {
            return nullptr;
        }

        if (k == p->key) {
            return p;
        } else if (k < p->key) {
            return search(p->left, k);
        } else {
            return search(p->right, k);
        }
    }

深度遍历（前序、中序、后序遍历）

    void BST::preOrder() {
        preOrder(root);
    }

    void BST::inOrder() {
        inOrder(root);
    }

    void BST::postOrder() {
        postOrder(root);
    }

    void BST::preOrder(Node *p) {
        if (p) {
            std::cout << p->key << "->" << p->value << " ";
            preOrder(p->left);
            preOrder(p->right);
        }
    }

    void BST::inOrder(Node *p) {
        if (p) {
            inOrder(p->left);
            std::cout << p->key << "->" << p->value << " ";
            inOrder(p->right);
        }
    }

    void BST::postOrder(Node *p) {
        if (p) {
            postOrder(p->left);
            postOrder(p->right);
            std::cout << p->key << "->" << p->value << " ";
        }
    }

广度遍历（层序遍历）

    void BST::levelOrder() {
        levelOrder(root);
    }

    void BST::levelOrder(Node *p) {
        if (!p) {
            return;
        }
        std::queue<Node *> q;
        q.push(p);
        while (!q.empty()) {
            auto node = q.front();
            std::cout << node->key << "->" << node->value << " ";
            q.pop();

            if (node->left) {
                q.push(node->left);
            }
            if (node->right) {
                q.push(node->right);
            }
        }
    }

获取最大/最小节点

    int BST::maxinum() {
        assert(count > 0);
        Node *node = maxinum(root);
        return node->key;
    }

    int BST::mininum() {
        assert(count > 0);
        Node *node = mininum(root);
        return node->key;
    }

    Node *BST::maxinum(Node *p) {
        auto node = p;
        while (node->right) {
            node = node->right;
        }
        return node;
    }

    Node *BST::mininum(Node *p) {
        auto node = p;
        while (node->left) {
            node = node->left;
        }
        return node;
    }

删除最大/最小节点

   void BST::removeMax() {
        if (root) {
            root = removeMax(root);
        }
    }

    void BST::removeMin() {
        if (root) {
            root = removeMin(root);
        }

    }

    Node *BST::removeMax(Node *p) {
        // 迭代实现
        if (p->right == nullptr) {
            // 根节点无右子树
            Node *lnode = p->left;
            delete p;
            return lnode;
        }
        // 迭代到待删除最小节点
        auto p1 = p;
        auto p2 = p->right;
        while (p2->right) {
            p1 = p2;
            p2 = p2->right;
        }
        p1->right = p2->left;  // 最大节点可能还有左子节点
        delete p2;
        --count;
        return p;
    }

    Node *BST::removeMin(Node *p) {
        // 迭代实现
        if (p->left == nullptr) {
            // 根节点无左子树
            Node *rnode = p->right;
            delete p;
            return rnode;
        }
        // 迭代到待删除最小节点
        auto p1 = p;
        auto p2 = p->left;
        while (p2->left) {
            p1 = p2;
            p2 = p2->left;
        }
        p1->left = p2->right;  // 最小节点可能还有右子节点
        delete p2;
        --count;
        return p;
    }

前驱与后继

   // 前驱/后继
    Node *BST::predecessor(int key) {
        Node *node = search(root, key);
        // 如果key所在的节点不存在, 则key没有前驱, 返回NULL
        if (node == nullptr) {
            return nullptr;
        }

        // 如果key所在的节点左子树不为空,则其左子树的最大值为key的前驱
        if (node->left != nullptr) {
            return maxinum(node->left);
        }

        // 否则, key的前驱在从根节点到key的路径上, 在这个路径上寻找到比key小的最大值, 即为key的前驱，即key所在节点的左、右父母中搜寻
        Node *tmpNode = predecessorFromAncestor(root, key);
        if (tmpNode != nullptr) {
            return tmpNode;
        }
        return nullptr;
    }

    Node *BST::predecessorFromAncestor(Node *p, int key) {
        if (p->key == key) {
            return nullptr;
        }

        if (key < p->key) {
            // 如果当前节点大于key, 则当前节点不可能是比key小的最大值
            // 向下搜索到的结果直接返回
            return predecessorFromAncestor(p->left, key);
        } else {
            // 如果当前节点小于key, 则当前节点有可能是比key小的最大值
            // 向右继续搜索, 将结果存储到tempNode中
            Node *tmpNode = predecessorFromAncestor(p->right, key);
            if (tmpNode != nullptr) {
                // 如果tempNode为空, 则当前节点即为结果
                return tmpNode;
            } else {
                return p;
            }
        }
    }

    Node *BST::successor(int key) {
        Node *node = search(root, key);
        // 如果key所在的节点不存在, 则key没有前驱, 返回NULL
        if (node == nullptr) {
            return nullptr;
        }

        // 如果key所在的节点右子树不为空,则其右子树的最小值为key的后继
        if (node->right != nullptr) {
            return mininum(node->right);
        }

        // 否则, key的后继在从根节点到key的路径上, 在这个路径上寻找到比key大的最小值, 即为key的后继，即在key的右父母中搜寻
        Node *tmpNode = successorFromAncestor(root, key);
        if (tmpNode != nullptr) {
            return tmpNode;
        }
        return nullptr;
    }

    Node *BST::successorFromAncestor(Node *p, int key) {
        if (key == p->key) {
            return nullptr;
        }

        if (p->key < key) {
            // 如果当前节点小于key, 则当前节点不可能是比key大的最小值
            // 向下搜索到的结果直接返回
            return successorFromAncestor(p->right, key);
        } else {
            // 如果当前节点大于key, 则当前节点有可能是比key大的最小值
            // 向左继续搜索, 将结果存储到tempNode中
            Node *tmpNode = successorFromAncestor(p->left, key);
            if (tmpNode != nullptr) {
                return tmpNode;
            } else {
                // 如果tempNode为空, 则当前节点即为结果
                return p;
            }
        }
    }

删除任意节点

  // 删除任意节点
    void BST::removeNode(int key) {
        if (contain(key)) {
            root = removeNode(root, key);
        }
    }

    Node *BST::removeNode(Node *p, int key) {
        if (key < p->key) {
            p->left = removeNode(p->left, key);
            return p;
        } else if (key > p->key) {
            p->right = removeNode(p->right, key);
            return p;
        } else {
            if (p->left == nullptr) {
                auto res = p->right;
                delete p;
                return res;
            } else if (p->right == nullptr) {
                auto res = p->left;
                delete p;
                return res;
            } else {
                auto minNode = mininum(p->right);
                Node *newNode = new Node(minNode->key, minNode->value);
                newNode->left = p->left;
                newNode->right = removeMin(p->right);
                return newNode;
            }
        }
    }

floor/ceil

    // floor/ceil
    int *BST::floor(int key) {
        if (count == 0 || key < mininum()) {
            return nullptr;
        }
        Node *node = floor(root, key);
        return &(node->key);
    }

    int *BST::ceil(int key) {
        if (count == 0 || key > maxinum()) {
            return nullptr;
        }
        Node *node = ceil(root, key);
        return &(node->key);
    }

    Node *BST::floor(Node *p, int key) {
        if (p == nullptr) {
            // attention 这儿返回空的含义
            return nullptr;
        }
        // 如果p的key值和要寻找的key值相等
        // 则p本身就是key的floor节点
        if (p->key == key) {
            return p;
        }

        // 如果p的key值比要寻找的key值大
        // 则要寻找的key的floor节点一定在p的左子树中
        if (p->key > key) {
            return floor(p->left, key);
        }

        // 如果p->key < key
        // 则p有可能是key的floor节点, 也有可能不是(存在比p->key大但是小于key的其余节点)
        // 需要尝试向p的右子树寻找一下
        Node *res = floor(p->right, key);
        if (res != nullptr) {
            return res;
        }
        return p;
    }

    Node *BST::ceil(Node *p, int key) {
        if (p == nullptr) {
            // attention 这儿返回空的含义
            return nullptr;
        }
        // 如果p的key值和要寻找的key值相等
        // 则p本身就是key的ceil节点
        if (p->key == key) {
            return p;
        }

        // 如果p的key值比要寻找的key值小
        // 则要寻找的key的ceil节点一定在p的右子树中
        if (p->key < key) {
            return ceil(p->right, key);
        }

        // 如果p->key > key
        // 则p有可能是key的ceil节点, 也有可能不是(存在比p->key小但是大于key的其余节点)
        // 需要尝试向p的左子树寻找一下
        Node *res = ceil(p->left, key);
        if (res != nullptr) {
            return res;
        }
        return p;
    }

销毁节点

    void BST::destory(Node *p) {
        if (p) {
            destory(p->left);
            destory(p->right);
            delete p;
            --count;
        }
    }

 

测试

1）前驱、后继测试

   // 二叉搜索树前驱后继节点测试
    void BSTPreAndSucTest() {
        const int N = 1000;
        int arr[N];
        for (int i = 0; i < N; ++i) {
            arr[i] = i;
        }
        // [0, N-1]的数据打乱后插入二叉搜索树中
        std::random_shuffle(arr, arr + N);

        BST bst;
        for (auto v : arr) {
            bst.insert(v, v);
        }

        for (int i = 1; i < N - 1; ++i) {
            assert(bst.predecessor(i)->key == i - 1);
            assert(bst.successor(i)->key == i + 1);
        }
        return;
    }

2）floor / ceil测试

    // 二叉搜索树 floor  / ceil 测试
    void BSTFloorAndCeilTest() {
        const int N = 1000;
        int arr[N];
        for (int i = 0; i < N; ++i) {
            arr[i] = 2 * i;
        }
        // [0, 2, 4.... 2*(N-1)]的数据打乱后插入二叉搜索树中
        std::random_shuffle(arr, arr + N);

        BST bst;
        for (auto v : arr) {
            bst.insert(v, v);
        }

        for (int i = 0; i < N - 1; ++i) {
            if (i % 2 == 0) {
                // 所有偶数在二叉树中存在，则其 floor / ceil 均为其本身
                assert(bst.floor(2 * i)->key == 2 * i);
                assert(bst.ceil(2 * i)->key == 2 * i);
            } else {
                // 所有基数在二叉树中不存在，则其 floor / ceil 均为其本身 +1 或者 -1
                assert(bst.floor(i)->key == i - 1);
                assert(bst.ceil(i)->key == i + 1);
            }
        }

        bst.removeNode(2);
        assert(bst.floor(2)->key ==  0);
        assert(bst.ceil(2)->key ==  4);
        return;
    }

3）其他测试

    // 二叉搜索树测试
    void BSTTest() {
        BST bstree;
        // 插入
        bstree.insert(5, 50);
        bstree.insert(4, 40);
        bstree.insert(9, 90);
        bstree.insert(1, 10);
        bstree.insert(7, 70);
        bstree.insert(3, 30);
        bstree.insert(6, 60);
        bstree.insert(8, 80);
        bstree.insert(11, 110);
        bstree.insert(10, 100);

        // 深度遍历遍历
        bstree.preOrder();
        std::cout << std::endl;
        bstree.inOrder();
        std::cout << std::endl;
        bstree.postOrder();
        std::cout << std::endl;
        // 广度遍历
        bstree.levelOrder();
        std::cout << std::endl;

        // 搜索
        auto sv = bstree.search(10);
        bool cv = bstree.contain(10);
        sv = bstree.search(11);
        cv = bstree.contain(11);
        sv = bstree.search(8);
        cv = bstree.contain(8);
        sv = bstree.search(13);
        cv = bstree.contain(13);

        // 最大最小值
        int minnum = bstree.mininum();
        int maxnum = bstree.maxinum();
//        bstree.removeMin();
//        bstree.levelOrder();
//        std::cout << std::endl;
//        bstree.removeMax();
//        bstree.levelOrder();
//        std::cout << std::endl;

        // 删除任意节点
//        bstree.removeNode(8);
//        bstree.levelOrder();
//        std::cout << std::endl;
//        bstree.removeNode(1);
//        bstree.levelOrder();
//        std::cout << std::endl;
//        bstree.removeNode(4);
//        bstree.levelOrder();
//        std::cout << std::endl;
//        bstree.removeNode(8);
//        bstree.levelOrder();
//        std::cout << std::endl;
//        bstree.removeNode(9);
//        bstree.levelOrder();
//        std::cout << std::endl;

        // floor/ceil
        auto floorv = bstree.floor(4);
        floorv = bstree.floor(2);
        floorv = bstree.floor(0);
        floorv = bstree.floor(3);

        auto ceilv = bstree.ceil(5);
        ceilv = bstree.ceil(12);
        ceilv = bstree.ceil(2);
        ceilv = bstree.ceil(3);
        ceilv = bstree.ceil(8);

        return;
    }

参考：

https://blog.csdn.net/weixin_42983849/article/details/105622493

https://github.com/liuyubobobo/Play-with-Algorithms/blob/master/05-Binary-Search-Tree/Course%20Code%20(C%2B%2B)/Optional-05-Floor-and-Ceil-in-BST/main.cpp

klbc
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
c++关联容器用法详解（set与map）
01-27
1. map和set的插入和删除效率较高，是因为它们内部采用红黑树实现，插入和删除仅涉及节点的调整，不涉及元素的内存拷贝和移动。 2. insert操作后，已存在的iterator不会立即失效，因为元素内存未改变，iterator仍然...
C++基础知识【8】模板
从此不归路
04-13 598
C++模板是一种允许程序员编写通用代码的机制。它们允许函数、类和数据类型适用于不同类型的参数，使得代码可以在不同类型之间进行重用。C++模板是C++编程中非常重要的一部分，它允许程序员以一种通用的方式编写代码，以便代码可以在不同类型之间进行重用。
【C++进阶】五、AVL树
枫叶先生的博客
03-09 713
AVL树的概念 | AVL树节点的定义 | AVL树的插入 | AVL树的旋转 | AVL树的验证和性能详解
C++实现的二叉树创建和遍历，超入门邻家小女也懂了_c++二叉树的建立与遍历
最新发布
m0_60607371的博客
04-21 757
空结点一般用null描述，如：{1,2,3,4,5,6,7,8,null,10,11,null,13,null,15}。遍历结果： 1 [2 [4 8 9] [5 10 11]] [3 [6 12 13] [7 14 15] “遍历结果： [[8 4 9] 2 [10 5 11]] 1 [[12 6 13] 3 [14 7 15]] “遍历结果： [[8 9 4] [10 11 5] 2] [[12 13 6] [14 15 7] 3] 1 “否则（1）访问根节点；（3）先序遍历右子树。
C++---二叉搜索树
qq_47406941的博客
05-19 619
一、二叉搜索树的概念 二叉搜索树又称二叉排序树，它是一颗空树或者是具有以下性质的树： 若它的左子树不为空，则左子树上所有节点的值都小于根节点的值 若它的右子树不为空，则右子树上所有节点的值都大于根节点的值 它的左右子树也分别为二叉搜索树 二、二叉搜索树的操作 1、查找 基本思路： 根节点为空，返回false 根节点不为空，比较根节点和要找的值是否相等，相等返回true。 根节点和要找的值不想等时，判断跟节点和要找的值的关系。 如果根节点小于要找到的值，则在右子树找 如果根节点大于要
【C++之容器篇】二叉搜索树的理论与使用
胡坚涛的博客
02-16 589
在数据结构初阶我们学习了二叉树的相关知识，普通的二叉树的作用只是用来存储数据，并没有任何的性质，所以在任何方面都没有什么优势，今天学习的二叉搜索树是在普通的二叉树的基础上加上了一些性质，使整体的搜索效率大大提升
实习面试记录
weixin_45485072的博客
09-04 607
在C++标准库中，vector和map都是基于模板类实现的容器。vector底层实现：vector是一个动态数组，它在内存中以连续的块存储元素。当需要添加或删除元素时，vector会根据需要自动重新分配内存空间，以保持元素的连续存储。通常情况下，vector会分配比实际需求大一些的内存空间，以避免频繁的重新分配开销。map底层实现：map是一个键-值对的关联容器，底层使用红黑树（Red-Black Tree）实现。红黑树是一种自平衡二叉搜索树，它具有良好的查找、插入和删除性能。
AVL树/B树/红黑树/二叉搜索树/并查集/哈夫曼树/字典树实现合集（C++）
05-25
本文将深入探讨几种重要的数据结构，包括AVL树、B树、红黑树、二叉搜索树、并查集、哈夫曼树和字典树，并概述它们的实现原理和应用场景。 首先，我们来看**AVL树**，它是一种自平衡的二叉搜索树。在AVL树中，任意...
STL AVL map/set library-开源
04-26
总的来说，这个开源的STL AVL map/set库提供了一种高效且与g++兼容的替代方案，尤其对于那些需要快速查找和高度平衡的二叉搜索树应用来说。通过使用AVL树，开发者可以期待更稳定的性能，尤其是在大型数据集和频繁...
红黑树和二叉搜索树的C语言实现及性能比较
04-03
本实验探讨了两种常见的自平衡二叉查找树——红黑树（Red-Black Tree）和二叉搜索树（Binary Search Tree），并用C语言实现了这两种数据结构，同时进行了性能比较。 首先，我们要理解二叉搜索树的基本特性。二叉...
使用C++实现的rbtree红黑树.zip
03-21
红黑树（Red-Black Tree）是一种自平衡的二叉...红黑树广泛应用于各种数据结构和算法中，如STL中的map和set容器，以及数据库索引等场景。理解和掌握红黑树的原理及C++实现，对于提升编程能力和解决实际问题大有裨益。
浅谈C++容器
dearwind153的专栏
04-10 597
什么是容器 首先，我们必须理解一下什么是容器，在C++ 中容器被定义为：在数据存储上，有一种对象类型，它可以持有其它对象或指向其它对像的指针，这种对象类型就叫做容器。很简单，容器就是保存其它对象的对象，当然这是一个朴素的理解，这种“对象”还包含了一系列处理“其它对象”的方法，因为这些方法在程序的设计上会经常被用到，所以容器也体现了一个好处，就是“容器类是一种对特定代码重用问题的良好的解决方案”。
4.map使用以及底层实现
ophlr
02-15 598
map 和slice类似, map也是引用类型, 当map被复制为一个新的变量时, 他们只想同一个内部数据结构. 因此改变其中一个变量, 另一个也会收到影响. package main import "fmt" func main() { personSalary := map[string]int{ "steve": 12000, "jamie": 15000, } personSalary["mike"] = 9000 fmt.Println("Original person sal
C++通过容器创建二叉树以及遍历（递归/非递归：前、中、后、层）————附带详细代码
韩江雪de 小屋
01-07 1196
文章目录0 背景1 生成二叉树1.1 二叉树的链式存储结构1.2 二叉树的创建2 遍历代码2.1 前序遍历2.1.1 递归2.2 非递归2.2 中序遍历2.2.1 递归2.2.2 非递归2.3 后序遍历2.3.1 递归2.3.2 非递归2.4 层序遍历3 完整的示例代码4 关联二叉查找树的创建 0 背景 在学习二叉树的遍历时，学习了很多遍历的方式，但是想要验证遍历的代码，奈何很多书籍都没有讲如何创建二叉树，网上也查了很多资料都是需要手动输入一个一个的节点通过递归来创建，不能传一个容器过去，通过容器中的元
map底层实现原理
qq_51537858的博客
11-22 4010
每个哈希表的实现对负载因子容忍程度不同，比如Redis实现中负载因子大于1时就会触发rehash，而Go则在在负载因子达到6.5时才会触发rehash，因为Redis的每个bucket只能存1个键值对，而Go的bucket可能存8个键值对，所以Go可以容忍更高的负载因子。上图可见，overflow的bucket中大部分是空的，访问效率会很差。这样，我们实际上每次修改的都是指针所指向的Student空间，指针本身是常指针，不能修改，只读属性，但是指向的Student是可以随便修改的，而且这里并不需要值拷贝。
散列表原理
fishycx的专栏
05-28 721
一、什么是散列表 散列表，又叫哈希表（Hash Table），是能够通过给定的关键字的值直接访问到具体对应的值的一个数据结构。也就是说，把关键字映射到一个表中的位置来直接访问记录，以加快访问速度。 通常，我们把这个关键字称为 Key，把对应的记录称为 Value，所以也可以说是通过 Key 访问一个映射表来得到 Value 的地址。而这个映射表，也叫作散列函数或者哈希函数，存放记录的数组叫作散列表。 目前，这个哈希函数比较常用的实现方法比较多，通常需要考虑几个因素：关键字的长度、哈希表的大小、关键字的分布情
C++ map的简单实现
WhiteShirtI的博客
05-23 5511
map和set的底层都是通过红黑树来实现的，但并不是原生态的红黑树，而是经过改造后的红黑树。且容器都会在各自的类中添加一些独特的函数来解决各自适配的问题 map和set底层是改造后的红黑树，我们先来看看改造后的红黑树 和普通的红黑树不同的是，在根节点上再加了一个头结点，该结点不是真实的结点，只是一个辅助结点，是为了后面实现红黑树的迭代器而出现的。该header结点的父节点就是真实的根节点，其左孩子是这棵树的最左结点，其右孩子是这棵树的最右节点。 我们现在通过STL源码来简单剖析一下map和set中如何利用
C++二叉树的代码实现（含迭代器）
m0_51797936的博客
06-27 1913
带迭代器二叉树的C++实现
C++STL 二叉搜索树
09-06
C++ STL中没有直接提供二叉搜索树的实现，但STL中有一些关于树的容器，比如set和map，它们底层的实现就是基于红黑树（一种平衡二叉搜索树）的。你可以使用这些容器来实现二叉搜索树的功能。关于二叉搜索树的一些知识...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值