STL(6)—红黑树的简易实现(仅插入功能)与set和map的封装实现

最新推荐文章于 2024-11-10 22:49:00 发布
最新推荐文章于 2024-11-10 22:49:00 发布
阅读量370 收藏 1
点赞数 1
分类专栏： C/C++学习 高级数据结构 文章标签： 数据结构 C++ 红黑树 map set
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/CS_COPy/article/details/124895566
版权
本文深入探讨了红黑树的特性，包括其平衡规则、插入操作、验证方法和在STL中的应用。通过实例展示了如何用C++实现红黑树，并封装成简单的map和set。同时，文章提到了红黑树相对于AVL树的优势，以及在数据结构中的重要地位。
摘要由CSDN通过智能技术生成

- 本人的LeetCode账号：Router，欢迎关注获取每日一题题解，快来一起刷题呀~

一、红黑树的介绍

  红黑树是通过着色限制最长路径长度不超过最短路径的2倍，从而控制了红黑树的近似平衡，不同于AVL树，它并不是严格平衡的。

1 红黑树的规则

  1. 每个结点不是红色就是黑色
  2. 根节点是黑色的
  3. 如果一个节点是红色的，则它的两个孩子结点是黑色的 ，即红黑树的路径中不存在连续红结点。
  4. 对于每个结点，从该结点到其所有后代叶结点的简单路径上，均包含相同数目的黑色结点 ，即每条路径的黑色结点数量相等，这里的路径是要一直到根节点的。
  5. 每个叶子结点都是黑色的(此处的叶子结点指的是空结点)

  分析，如果存在最短路径，极端的最短路径就是全黑的结点，最长路径的极端情况是一黑一红(根据规则3，结点不能连续存在)，而每条路径的黑色结点数量都相等，最长的路径长度不超过最短路径的2倍。

  假设任意一条路径的黑结点个数为N，则N<=任意路径长度<=2N。

  第二个节点插入时，第二个节点必然是红结点，路径长度就不满足了，性质4可能就对不上了：

2 理解红黑树的相对平衡

  AVL树左右两边更加均衡，高度控制在logN；

  红黑树的左右两边没有那么均衡，当最长路径长度超过最短路径的2倍，它就一定要旋转。

  假设红黑树中一条路径黑色结点的数量是X，红黑树的高度h就一定满足X <= h <= 2X。

  那么结点数量N最少是高度为X的满二叉树对应个数（全黑的满二叉树），最多是高度为2X的满二叉树结点个数（一黑一红的满二叉树），即
2 X − 1 < = N < = 2 2 X − 1 1 2 l o g 2 ( N + 1 ) < = X < = l o g 2 ( N + 1 ) 2^X - 1<=N<=2^{2X} - 1\\ \frac{1}{2}log_2(N+1)<=X<=log_2(N+ 1)\\ 2X−1<=N<=22X−121​log2​(N+1)<=X<=log2​(N+1)
  所以红黑树的高度还是对数级别，最坏情况下是2logN的高度，这就是红黑树近似平衡的含义。

  对比AVL树的严格平衡，它的增删查的效率是严格logN，而红黑树是近似平衡，它增删查的效率是logN，因为是对数级别，所以就算14亿也就30层，2logN也就60层，对CPU来说查找其实没有啥区别。

  但是AVL树的更加平衡是付出了更多的旋转(删除时可能一直旋转到根)达到的，同样的一个树的模样，红黑树可能不旋转，AVL树可能要旋转。

3 红黑树的结构

  首先我们仍然保持三叉链结构，因为需要给结点染色，所以我们再增加一个枚举类型，代表红色和黑色，其结点结构体如下：

enum Color
{
	RED = 0,
	BLACK = 1
};

template <class K, class V>
struct RBTreeNode
{
    // 默认染色为红色
	RBTreeNode(const pair<K, V>& kv) 
		: _kv(kv), _left(nullptr), _right(nullptr), _parent(nullptr), _color(RED)
	{}
	RBTreeNode<K, V>* _left;
	RBTreeNode<K, V>* _right;
	RBTreeNode<K, V>* _parent;
	pair<K, V> _kv;
	Color _color;
};

  然后我们的红黑树的模板类就是封装一个根节点，无参构造函数把红黑树的根节点置成nullptr：

template <class K, class V>
class RBTree
{
	typedef RBTreeNode<K, V> Node;
public:
	RBTree() : _root(nullptr) {}
private:
	Node* _root;
};

4 红黑树的插入

  因为插入黑色结点可能会影响所有路径，所以我们默认新插入的结点cur为红色结点比较好。

  插入过程的整体框架与AVL树类似，首先根据二叉搜索树的方法，找到对应位置并插入，新插入位置为cur，其父亲为parent，因为cur我们一直控制成红色的，如果其父亲不为空且父亲为红色结点，则需要调整红黑树。

  如果约定cur为新增结点，p为新增结点的父节点，g为新增结点的祖父结点，u为新增结点的叔叔结点；

  可以发现，只要父亲不是红色结点，我们就不会违反规则，但是当父亲也是红色结点时，我们需要调整红黑树以满足它的规则：

  • 情况1：cur是红色，p是红色，g是黑色，u是红色

  解决方法：p染成黑色，u染成黑色，g染成红色，把g当做cur继续向上调整；

  父亲是祖父的左孩子的情况：

  父亲是祖父的右孩子的情况：

  因为为了解决新增结点导致的连续红结点问题，所以要把p染黑，然后因为把p染黑了，这个子树内黑结点多了一个，所以需要把u也染黑保证子树范围内黑结点个数相等，把p和u染黑色以后，就保证了这个子树范围内路径长度相等，但是相对其他的子树，这个子树的路径长度增加了1，所以要把g染成红色减少一个黑色结点，并继续往上调整。

  • 情况2：cur是红、p为红、g为黑、u不存在或u存在且为黑

  根据cur和parent和grandfather的位置关系，可以分成以下四种情况：

  右单旋情况：父亲是祖父左孩子且cur是父亲左孩子：

  左右双旋情况:父亲是祖父左孩子且cur是父亲右孩子

  右左双旋情况:父亲是祖父右孩子且cur是父亲左孩子

  左单旋情况：父亲是祖父右孩子且cur是父亲右孩子

  并且这四种旋转有一种好处，它把当前子树的根弄成了黑色，不用再往上调整了。

  综上，综合代码如下：

// 插入
bool Insert(const pair<K, V> &kv)
{
    if (_root == nullptr)
    {
        _root = new Node(kv);
        _root->_color = BLACK;
        return true;
    }
    Node *parent = nullptr;
    Node *cur = _root;
    while (cur)
    {
        if (cur->_kv.first > kv.first)
        {
            parent = cur;
            cur = cur->_left;
        }
        else if (cur->_kv.first < kv.first)
        {
            parent = cur;
            cur = cur->_right;
        }
        else
            return false;
    }
    // 插入一个结点 只会影响它的祖先的平衡因子
    cur = new Node(kv);
    cur->_parent = parent;
    if (parent->_kv.first > cur->_kv.first)
    {
        parent->_left = cur;
    }
    else
    {
        parent->_right = cur;
    }
    while (parent && parent->_color == RED)
    {
        // 父亲存在且为红 则父节点一定不是根
        Node *grandfather = parent->_parent;
        // 如果父亲是祖父的左
        if (parent == grandfather->_left)
        {
            // 叔叔就是祖父的右
            Node *uncle = grandfather->_right;
            if (uncle && uncle->_color == RED)
            {
                // 叔叔父亲弄成黑色 祖父染成红色 再往上处理
                parent->_color = uncle->_color = BLACK;
                grandfather->_color = RED;
                cur = grandfather;
                parent = cur->_parent;
            }
            // 叔叔不存在或叔叔存在且为黑
            else
            {
                //    g
                //  p   u
                // cur
                if (parent->_left == cur)
                {
                    // 左单旋
                    RotateL(grandfather);
                    parent->_color = BLACK;
                    grandfather->_color = RED;
                }
                //     g
                //  p    u
                //    cur
                // 左右双旋
                else
                {
                    RotateL(parent);
                    RotateR(grandfather);
                    // 染色
                    cur->_color = BLACK;
                    grandfather->_color = RED;
                }

                break;
            }
        }
        else
        {
            // 父亲是祖父的右
            Node *uncle = grandfather->_left;
            if (uncle && uncle->_color == RED)
            {
                // 叔叔父亲弄成黑色 祖父染成红色 再往上处理
                parent->_color = uncle->_color = BLACK;
                grandfather->_color = RED;
                cur = grandfather;
                parent = cur->_parent;
            }
            // 叔叔不存在或叔叔存在且为黑
            else
            {
                //  g
                //     p
                //        cur
                if (parent->_right == cur)
                {
                    // 右单旋
                    RotateL(grandfather);
                    parent->_color = BLACK;
                    grandfather->_color = RED;
                }
                //  g
                //      p
                //   cur
                // 右左双旋
                else
                {
                    RotateR(parent);
                    RotateL(grandfather);
                    // 染色
                    cur->_color = BLACK;
                    grandfather->_color = RED;
                }

                break;
            }
        }
    }
    // 单独把根染黑
    _root->_color = BLACK;
    return true;
}

5 红黑树的验证

  首先，直接能通过遍历并不能说明我们的数是红黑树，只能说明我们的树是一颗二叉搜索树，实际上，想验证树是红黑树应该通过验证规则是否成立验证，也就是像AVL树一样，我们单独去写一个检查来验证。

  根为黑，很好检查；没有连续的红结点也很好检查，遍历每个结点，如果结点为红且父亲为弄，则往回返回false，对每个结点去检查其父亲的颜色比检查其孩子要轻松很多。

  先把我们上面讨论的规则的验证实现一下：

// 检查是否为红黑树
bool isbalance()
{
    if (_root && _root->_color == RED)
    {
        cout << "违反根结点是黑色的规则" << endl;
        return false;
    }
    return _isbalance(_root);
}
bool _isbalance(Node *root)
{
    if (root == nullptr)
        return true;

    if (root->_color == RED && root->_parent && root->_parent->_color == RED)
    {
        cout << "出现连续的红结点" << endl;
        return false;
    }

    return _isbalance(root->_left) && _isbalance(root->_right);
}

  接下来要检查每条路径的黑色结点数量都相等，显然使用一个dfs就可以，参数里头带一个当前黑色结点数量，走到空时说明一条路径结束了。

  我们可以首先以最左边的路径的黑色结点个数为每条路径上的黑色结点数量的参考值，然后通过dfs得到每条路径的黑色结点数量，每遍历到一个根节点，就得到了一条路径，每次得到一条路径后比较一下该路径的黑色结点数量和黑色结点基准值是否相等即可。

// 检查是否为红黑树
bool isbalance()
{
    if (_root && _root->_color == RED)
    {
        cout << "违反根结点是黑色的规则" << endl;
        return false;
    }
    // 获得最左路径的黑结点数量
    int banchmark = 0;
    Node *left = _root;
    while (left)
    {
        if (left->_color == BLACK)
            ++banchmark;
        left = left->_left;
    }

    return _isbalance(_root, banchmark, 0);
}

bool _isbalance(Node *root, int banchmark, int blacknum)
{
    if (root == nullptr)
    {
        if (banchmark != blacknum)
        {
            cout << "存在路径黑色结点的数量不相等" << endl;
            return false;
        }
        return true;
    }

    if (root->_color == RED && root->_parent && root->_parent->_color == RED)
    {
        cout << "出现连续的红结点" << endl;
        return false;
    }

    // 统计一个路径的黑色结点数量
    if (root->_color == BLACK)
        ++blacknum;

    return _isbalance(root->_left, banchmark, blacknum) && _isbalance(root->_right, banchmark, blacknum);
}

  每次插入后都检查一下，验证一下我们的红黑树插入没有问题：

void RBTreetest1()
{
	RBTree<int, int> rbt1;
	int a[] = { 4, 2, 6, 1, 3, 5, 15, 7, 16, 14 };
	const int N = 100000000;
	for (auto e : a)
	{
		rbt1.Insert(make_pair(e, e));
		cout << e << ':' << rbt1.isbalance() << endl;
	}
}

  然后我们来看看红黑树的层数，开release版本往红黑树中插入1e9个结点：

  可以看出红黑树的效率还是非常不错的。

6 红黑树的删除

  因为其较为复杂，因此我们这里不做讲解，详情可参考这篇博客：红黑树 - Never - 博客园 (cnblogs.com)

7 红黑树的应用

  1. C++ STL库 – map/set、mutil_map/mutil_set
  2. Java 库
  3. linux内核
  4. 其他一些库

  基本红黑树就是数据加载到内存的二叉搜索树中综合性能最好的了。

  数据库中，为快速检索数据，一般会将数据在磁盘中以B树系列结构来存储，B树是一颗多叉树，层数更低。

二、仅插入功能的红黑树封装出一个简单的map和set

1 STL中的架构

  STL中，仅用一颗V的红黑树就实现出了map和set，我们来具体看看它是怎么做到的。

  可见STL中是把红黑树的结点模板参数仅限制为一个，即树的节点存的值中的值的类型是什么，红黑树的类模板参数的第一个参数为关键字，第二个模板参数为节点值类型，如果是map就是一个pair，如果是set就是一个普通的T。

  为了控制set和map比较方式的不同，增加一个模板参数Compare，它来保证我们的T是从什么东西来比。

  即让map和set传给红黑树一个模板参数，它是一个函数对象，然后通过这个告知红黑树从T的什么东西是关键字，然后用这个函数对象提取出这个关键字进行比较，set就直接通过值比较，map通过.first比较

2 set和map的第一层封装

// map
namespace Router
{
	template <class K, class V>
	class map
	{
	public:
		// 指定T内哪个是关键字
		struct MapKeyofT
		{
			const K& operator()(const pair<K, V>& kv)
			{
				return kv.first;
			}
		};
		bool insert(const pair<K, V>& kv)
		{
			_t.Insert(kv);
		}
	private:
		// 关键字 树中结点值
		RBTree<K, pair<K, V>, MapKeyofT> _t;
	};
}
// set
namespace Router
{
	template <class T>
	class set
	{
	public:
		struct SetKeyofT
		{
			const T& operator()(const T& k)
			{
				return k;
			}
		};
		bool insert(const T& key)
		{
			return _t.Insert(key);
		}
	private:
		RBTree<T, T, SetKeyofT> _t;
	};
}

  根据STL的架构，我们修改一下那颗红黑树：

namespace Router
{
    enum Color
    {
        RED = 0,
        BLACK = 1
    };

    // 红黑树结点
    template <class T>
    struct RBTreeNode
    {
        // 默认染色为红色
        RBTreeNode(const T& data)
            : _data(data), _left(nullptr), _right(nullptr), _parent(nullptr), _color(RED)
        {}
        RBTreeNode<T>* _left;
        RBTreeNode<T>* _right;
        RBTreeNode<T>* _parent;
        T _data;
        Color _color;
    };

    // 红黑树 关键字,结点中的值,怎么从结点的值类型中得到关键字
    template <class K, class T, class KeyofT>
    class RBTree
    {
        typedef RBTreeNode<T> Node;
    public:
        RBTree() : _root(nullptr) {}
        void inorder()
        {
            _inorder(_root);
        }
        // 插入
        bool Insert(const T& data)
        {
            if (_root == nullptr)
            {
                _root = new Node(data);
                _root->_color = BLACK;
                return true;
            }
            Node* parent = nullptr;
            Node* cur = _root;
            KeyofT kot;
            while (cur)
            {
                if (kot(cur->_data) > kot(data))
                {
                    parent = cur;
                    cur = cur->_left;
                }
                else if (kot(cur->_data) < kot(data))
                {
                    parent = cur;
                    cur = cur->_right;
                }
                else
                    return false;
            }
            // 插入一个结点 只会影响它的祖先的平衡因子
            cur = new Node(data);
            cur->_parent = parent;
            if (kot(parent->_data) > kot(cur->_data))
            {
                parent->_left = cur;
            }
            else
            {
                parent->_right = cur;
            }
            while (parent && parent->_color == RED)
            {
                // 父亲存在且为红 则父节点一定不是根
                Node* grandfather = parent->_parent;
                // 如果父亲是祖父的左
                if (parent == grandfather->_left)
                {
                    // 叔叔就是祖父的右
                    Node* uncle = grandfather->_right;
                    if (uncle && uncle->_color == RED)
                    {
                        // 叔叔父亲弄成黑色 祖父染成红色 再往上处理
                        parent->_color = uncle->_color = BLACK;
                        grandfather->_color = RED;
                        cur = grandfather;
                        parent = cur->_parent;
                    }
                    // 叔叔不存在或叔叔存在且为黑
                    else
                    {
                        //    g
                        //  p   u
                        // cur
                        if (parent->_left == cur)
                        {
                            // 左单旋
                            RotateL(grandfather);
                            parent->_color = BLACK;
                            grandfather->_color = RED;
                        }
                        //     g 
                        //  p    u
                        //    cur
                        // 左右双旋
                        else
                        {
                            RotateL(parent);
                            RotateR(grandfather);
                            // 染色
                            cur->_color = BLACK;
                            grandfather->_color = RED;
                        }

                        break;
                    }
                }
                else
                {
                    // 父亲是祖父的右
                    Node* uncle = grandfather->_left;
                    if (uncle && uncle->_color == RED)
                    {
                        // 叔叔父亲弄成黑色 祖父染成红色 再往上处理
                        parent->_color = uncle->_color = BLACK;
                        grandfather->_color = RED;
                        cur = grandfather;
                        parent = cur->_parent;
                    }
                    // 叔叔不存在或叔叔存在且为黑
                    else
                    {
                        //  g
                        //     p
                        //        cur
                        if (parent->_right == cur)
                        {
                            // 右单旋
                            RotateL(grandfather);
                            parent->_color = BLACK;
                            grandfather->_color = RED;
                        }
                        //  g
                        //      p
                        //   cur
                        // 右左双旋
                        else
                        {
                            RotateR(parent);
                            RotateL(grandfather);
                            // 染色
                            cur->_color = BLACK;
                            grandfather->_color = RED;
                        }

                        break;
                    }
                }
            }
            // 单独把根染黑
            _root->_color = BLACK;
            return true;
        }
        // 检查是否为红黑树
        bool isbalance()
        {
            if (_root && _root->_color == RED)
            {
                cout << "违反根结点是黑色的规则" << endl;
                return false;
            }
            // 获得最左路径的黑结点数量
            int banchmark = 0;
            Node* left = _root;
            while (left)
            {
                if (left->_color == BLACK) ++banchmark;
                left = left->_left;
            }

            return _isbalance(_root, banchmark, 0);
        }
        int height()
        {
            return _height(_root);
        }
    private:
        Node* _root;
        // 右单旋
        void RotateR(Node* parent)
        {
            Node* subL = parent->_left;
            Node* subLR = subL->_right;
            Node* parentParent = parent->_parent;
            subL->_right = parent;
            parent->_parent = subL;
            parent->_left = subLR;
            if (subLR)
                subLR->_parent = parent;
            if (parent == _root)
            {
                _root = subL;
                subL->_parent = nullptr;
            }
            else
            {
                if (parentParent->_left == parent) parentParent->_left = subL;
                else parentParent->_right = subL;
                subL->_parent = parentParent;
            }
        }
        // 左单旋
        void RotateL(Node* parent)
        {
            Node* subR = parent->_right;
            Node* subRL = subR->_left;
            Node* parentParent = parent->_parent;
            parent->_parent = subR;
            subR->_left = parent;
            parent->_right = subRL;
            if (subRL) subRL->_parent = parent;
            if (parent == _root)
            {
                _root = subR;
                subR->_parent = nullptr;
            }
            else
            {
                if (parentParent->_left == parent)
                {
                    parentParent->_left = subR;
                }
                else parentParent->_right = subR;
                subR->_parent = parentParent;
            }
        }

        void _inorder(Node* root)
        {
            if (root == nullptr) return;
            _inorder(root->_left);
            cout << root->_kv.first << ":" << root->_kv.second << endl;
            _inorder(root->_right);
        }

        int _height(Node* root)
        {
            if (root == nullptr)
                return 0;
            int leftheight = _height(root->_left);
            int rightheight = _height(root->_right);
            return 1 + max(leftheight, rightheight);
        }

        bool _isbalance(Node* root, int banchmark, int blacknum)
        {
            if (root == nullptr)
            {
                if (banchmark != blacknum)
                {
                    cout << "存在路径黑色结点的数量不相等" << endl;
                    return false;
                }
                return true;
            }

            if (root->_color == RED && root->_parent && root->_parent->_color == RED)
            {
                cout << "出现连续的红结点" << endl;
                return false;
            }

            // 统计一个路径的黑色结点数量
            if (root->_color == BLACK) ++blacknum;

            return _isbalance(root->_left, banchmark, blacknum)
                && _isbalance(root->_right, banchmark, blacknum);
        }
    };
}

3 set和map的迭代器

  为实现访问map和set中的元素，我们提供迭代器，首先，仿照list的模拟实现中我们实现的迭代器：

// 迭代器
template <class T, class Ref, class Ptr>
struct RBTreeIterator
{
    typedef RBTreeNode<T> Node;
    typedef RBTreeIterator<T, Ref, Ptr> self;
    // 结点就是一个迭代器。
    Node *_node;
    RBTreeIterator(Node *node) : _node(node) {}
    // 解引用
    Ref operator*()
    {
        return _node->_data;
    }
    // ->
    Ptr operator->()
    {
        return &(_node->_data);
    }
    // ++迭代器 指向中序的下一个位置
    self &operator++()
    {
        //...

        // 最后返回解引用this
        return *this;
    }
    bool operator==(self& it)
    {
        return _node == it._node;
    }
    bool operator!=(self& it)
    {
        return !(*this == it);
    }
};

  然后在红黑树中增加迭代器，首先提供begin和end迭代器：

  根据走中序的规律，begin就是最左结点的的迭代器，end就是最右节点的后一个结点，即nullptr。

  接下来聚焦于operator++的逻辑，即中序的下一个：

  因为中序的顺序是左中右，++it，访问到it时，我们认为it的左树已经结束了，

  • 在中序顺序中，如果当前结点的右子树不为空，则“下一个结点“一定是右子树的最左结点。
  • 如果右子树是空，详情见下图：

  这就是三叉连的好处，方便的直接从孩子找到父亲，实现如下：

// ++迭代器 指向中序的下一个位置
self &operator++()
{
    Node *cur = this->_node;
    if (cur->_right)
    {
        Node *ans = cur->_right;
        while (ans && ans->_left)
            ans = ans->_left;
        _node = ans;
    }
    else
    {
        Node *parent = cur->_parent;
        while (parent && parent->_left != cur)
        {
            cur = parent;
            parent = cur->_parent;
        }
        _node = parent;
    }
    return *this;
}

  再给set和map提供迭代器的层，注意这里要指明这里是一个类型，因为这个类模板还没实例化，所以要用typename关键字。

  map

  set

  测试一下：(范围for是基于迭代器的，set用迭代器，map用范围for)

void test_set()
{
    set<int> myset;
    int a[] = {4, 2, 6, 1, 3, 5, 15, 7, 16, 14};
    for (auto c : a)
        myset.insert(c);
    auto it = myset.begin();
    while (it != myset.end())
    {
        cout << *it << endl;
        ++it;
    }
}

void test_map()
{
    map<int, int> mymap;
    mymap.insert(make_pair(1, 1));
    mymap.insert(make_pair(3, 3));
    mymap.insert(make_pair(-5, -5));
    mymap.insert(make_pair(-8, -8));
    mymap.insert(make_pair(9, 9));
    for (auto &p : mymap)
    {
        cout << p.first << ':' << p.second << endl;
    }
}

  operator–：与operator++顺序相反，它的顺序是右根左，如果当前结点的左子树不为空，则去访问左子树的最右节点。

  否则，沿着三叉连找第一个是父亲的右的节点，然后要访问的就是父亲节点。

self &operator--()
{
    Node *cur = this->_node;
    if (cur->_left)
    {
        Node *ans = cur->_left;
        while (ans && ans->_right)
            ans = ans->_right;
        _node = ans;
    }
    else
    {
        Node *parent = cur->_parent;
        // 否则沿着三叉连找到是父亲的右的节点
        while (parent && parent->_right != cur)
        {
            cur = parent;
            parent = parent->_parent;
        }
        _node = parent;
    }
    return *this;
}

  再提供一个find函数，首先在红黑树中提供find函数，然后map/set中提供一个接口即可。

iterator find(const K &key)
{
    Node *cur = _root;
    KeyofT kot;
    while (cur)
    {
        if (kot(cur->_data) < key)
            cur = cur->_right;
        else if (kot(cur->_data) > key)
            cur = cur->_left;
        else
            return iterator(cur);
    }
    return end();
}

  因为模板参数不支持修改map/set的底层数据结构，所以map/set并不是适配器。

4 map的operator[]

  首先修改插入的返回值：

  然后为map增加operator[]，其原理与我们之前在map中学习的operator[]一样：

5 析构函数、拷贝构造函数与赋值

  应对拷贝和赋值的场景：

set<int> s(p);
p = s;

  当前我们实现的是一个浅拷贝，如果增加一个析构函数，则会因为浅拷贝析构同一块资源两次寄了。

  所以先在红黑树中增加一个析构函数，其原理与销毁二叉搜索树一样，我们无需在set和map中增加析构函数和拷贝构造，因为对于自定义类型，编译器默认生成的这些函数会去掉对应类型的函数。

  然后以下代码就会崩溃：

  控制一个拷贝构造函数：

  然后测试代码就可以通过：

  赋值的现代写法：

  

魔术师的徒弟
关注
专栏目录
【C++】红黑树详解并封装实现map和set
love_guanghui的博客
03-18 3226
红黑树详解
【C++ STL】模拟实现 map 和 set（对一颗红黑树进行封装）
codewinter的博客
06-25 755
阅读STL源码就可以发现，其实 set 和 map 自己没有实现啥东西，整体就是对红黑树进行了一个封装，set 和 map 的 insert / erase 接口底层就是调用红黑树的 insert / erase 接口，并且 set 和 map 的迭代器也都是取的红黑树里面的迭代器那 set 和 map 的核心区别在哪里呢？set 底层封装了一颗红黑树，是 KV 结构，值得注意的是 key_type 和 value_type 都是 key，说明传了两个 key 给红黑树。 map 底层封装了一颗红黑树，是
C++STL详解(九)--使用红黑树封装实现set和map
清欢Allen的技术博客
04-19 716
如果我们用一棵KV模型的红黑树同时实现map和set,我们就需要控制map和set中的所传入红黑树中的模板参数,其中,封装过程中,为了与红黑树的模板参数区分,我们将红黑树中模板参数由V改成T.在插入中,结点中存储的类型T可能为Set容器中的key,也有可能是Map中的pair键值对,底层红黑树如何针对不同类型的容器进行比较呢?所以,当容器为set时,红黑树中的仿函数就实例化为set容器中的仿函数,当容器为map时,红黑树中的仿函数就实例化为map中的仿函数.正向迭代器还包括了==,!
从C语言到C++_29(红黑树封装set和map)红黑树迭代器的实现
参考书籍：《C语言程序设计》《数据结构》《C++ Primer》《Effective C++》《STL源码剖析》《现代操作系统》《UNIX环境高级编程》《图解TCP/IP》《图解HTTP》《Linux高性能服务器编程》《剑指Offer》《算法导论》
07-28 456
从C语言到C++_29（红黑树封装set和map）红黑树迭代器的实现，仿函数比较键值对。下一部分：unordered_set + unordered_map + 哈希表。
【C++】-- STL之用红黑树模拟实现map和set
局部变量和全局变量
09-08 1111
用红黑树同时封装出set和map时，set传给value的是一个value，map传给value的是一个pair，set和map传给红黑树的value决定了这棵树里面存的节点值类型。上层容器不同，底层红黑树的Key和T也不同。
用同一棵红黑树实现map和set【STL】
Man9o
11-25 594
反向迭代器的成员变量是一个正向迭代器，而它接收的模板参数是一个正向迭代器（被typedef的iterator），但是在正向迭代器的实现中，它能接收三种类型参数，即，但是反向迭代器不知道传入的结点是引用还是指针类型，所以还需要再正向迭代器的实现中对引用和指针类型再定义迭代器类型。// 结点指针 typedef Ref reference;// 结点指针的引用// 结点指针的引用 typedef typename iterator :: pointer Ptr;// 结点指针。
【C++/STL】：红黑树的应用 --- 封装map和set
2301_77900444的博客
07-27 1761
map 和 set 的底层本质上还是复用通过对红黑树的改造，再分别套上一层 map 和 set 的 “壳子”，以达到 “一树二用” 的目的。在改造红黑树的过程中，我大概归纳了以下几个需要重点解决的问题：(1) 对红黑树节点的改造。关联式容器中存储的是的键值对，K为key的类型，如果是 set 则是 K，如果是map，则为pair。如何用一个节点结构控制两种类型，使用类模板参数T。(2) 在插入操作时，如何完成数据的比较。
C++---红黑树模拟实现STL中的map与set
blue_jun_的博客
11-07 596
简要实现用RBTree封装map和set，包括迭代器的实现
【STL】模拟实现map和set {带头结点的红黑树；红黑树的核心结构；红黑树的迭代器；红黑树的插入和查找；map和set的封装}
52Herzt的博客
09-09 248
【STL】模拟实现map和set {带头结点的红黑树；红黑树的核心结构；红黑树的迭代器；红黑树的插入和查找；map和set的封装}
C++红黑树封装实现map和set模拟
本资源将通过封装红黑树来模拟实现map和set。红黑树是一种自平衡的二叉搜索树，通过对插入和删除操作的特定处理，它可以保证最坏情况下的时间复杂度为O(log n)，这对于需要高效搜索和插入操作的场景非常有用。 在...
C++红黑树的插入实现+红黑树迭代器实现+map/set封装红黑树
qq_53413129的博客
06-01 613
红黑树的基本编写 红黑树的概念 红黑树，是一种二叉搜索树，但在每个结点上增加一个存储位表示结点的颜色，可以是Red或Black。 通过对任何一条从根到叶子的路径上各个结点着色方式的限制，红黑树确保没有一条路径会比其他路径长出俩倍，因而是接近平衡的 红黑树的性质 每个节点不是红色就是黑色 根节点是黑色的 没有连续的红色节点，但是可以有连续的黑色节点 每条路径黑色节点数量相等 每个叶子节点都是黑色的（此处的叶子节点值得是空节点--NIL节点，不是以前真正意义上理解的叶子节点）。 假设每条路径
红黑树封装技术实现高效map和set
资源摘要信息: "本资源包含了红黑树封装的map和set源代码，是一种高级数据结构实现，属于C++标准模板库（STL）的一部分。红黑树（Red-Black Tree）是一种自平衡的二叉查找树，它在每个节点上增加了一个存储位表示...
二叉树遍历/算法&数据结构
2403_86942375的博客
11-10 682
其实很简单，根据遍历的顺序摆放遍历顺序和添加元素的顺序，(root.left, result)代表左子树，(root.right, result)代表右子树，(root.val)代表中节点。其实很简单，参数就是要目前遍历节点在哪，返回值也同理，终止条件就是指遍历到null的时候回溯，逻辑不要想复杂，根据顺序移动上述上个递归函数即可。前序（要理解遍历的核心，先把中节点塞入，然后根据栈去模拟，先加入右节点然后是左节点，移动到左节点继续加入）后序（就是前序遍历的左右调换顺序，然后再倒叙结果数组）
【初阶数据结构篇】二叉树OJ题
最新发布
braveact的博客
11-10 509
根节点与左右孩子的数值进行比较，如果相等依次递归左右子树，如果为空，或者两者对应的值相等，则返回true。🚀 分享给更多人：如果你觉得这篇文章对你有帮助，欢迎分享给更多对C++感兴趣的朋友，让我们一起进步！可以将该二叉树看成两个独立的二叉树，分别将“两个二叉树”的根节点传入，判断该是否为相同的二叉树。将两个数的根节点的值依次比较，依次递归两根节点的左子树，若根节点为空，直接返回。如果两个树在结构上相同，并且节点具有相同的值，则认为它们是相同的。期待你的三连，你的支持就是我创作的动力！
【数据结构】B树
藓类少女的博客
11-06 905
B树通常定义为一棵平衡的多路搜索树，并用一个整数 m 表示其阶数，即每个节点最多有 m 个子节点。每个节点最多包含 m - 1 个关键字和 m 个子节点。每个非根节点至少包含 ⌈m/2⌉−1 个关键字和 ⌈m/2⌉ 个子节点。根节点至少包含 1 个关键字，特殊情况除外（当树为空时，根节点没有关键字）。所有叶子节点都在同一层，即 B 树的高度是均匀的。每个节点的关键字从小到大排序，并且遵循左小右大的原则。每个关键字 k 的左子树的所有关键字都小于 k，右子树的所有关键字都大于 k。
希尔排序算法
a921876874的博客
11-06 998
希尔排序算法
python中常见的8种数据结构之一数组的应用
2301_81121233的博客
11-10 234
可能的类型码包括`b`（有符号整数）、`B`（无符号整数）、`u`（Unicode字符）、`h`（有符号短整数）、`H`（无符号短整数）、`i`（有符号整数）、`I`（无符号整数）、`l`（有符号长整数）、`L`（无符号长整数）、`f`（浮点数）、`d`（双精度浮点数）等。数组和列表的主要区别在于数组中的元素必须是同一种类型，而列表中的元素可以是任何类型。可以通过索引访问数组中的元素，也可以使用切片操作来获取数组的子集。3.音频处理：音频数据通常也以数组的形式存储，数组可以用来处理音频的采样值。
数据结构计算二叉树节点的个数
qq_45153375的博客
11-07 320
因此，这棵树中度为0的节点数 ( n_0 = 4 )，度为1的节点数 ( n_1 = 3 )。因此，这棵树中度为0的节点数 ( n_0 = 6 )，度为2的节点数 ( n_2 = 5 )。因此，这棵树的总节点数是 18，度为2的节点数 ( n_2 = 7 )。以下是几道练习题帮助理解如何计算度为1和度为0的节点数量。
【01课_初识算法与数据结构】
weixin_42333261的博客
11-10 653
算法，个人理解就是计算一段逻辑，最简化，最快速的方式、方法每个函数，就包含了一定的算法，执行一定的计算逻辑。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值