STL 底层剖析：map/set 如何封装红黑树及迭代器实现

深入解析 C++ STL 中 map 和 set 容器对红黑树的封装原理。重点阐述了 KeyOfT 提取规则、迭代器的 ++/-- 底层逻辑（右子树最左节点与回溯父节点），以及红黑树插入后的平衡调整策略。通过模拟实现代码，展示了 map 的键值对存储机制与 set 的去重排序特性，帮助理解 STL 底层数据结构的设计思想。

猫巷少女发布于 2026/3/30更新于 2026/4/131 浏览

map 和 set 的封装

map 和 set 在封装时对红黑树内部 K、T 的处理有所不同：

map：K 存储 Key，T 存储 pair<Key, Value>。Key 用于排序查找，Value 存储信息。
set：K 存储 Key，T 也存储 Key。键承担了所有功能。

对于 set，K 和 T 均不可被修改；对于 map，K 不可修改，但 T 中的 Value 可以修改。

namespace renshen {
template<class K, class V>
class map {
    struct MapKeyOfT {
        const K& operator()(const pair<K, V>& kv) {
            return kv.first;
        }
    };
public:
    typedef typename RBTree<K, pair<const K, V>, MapKeyOfT>::iterator iterator;
    typedef typename RBTree<K, pair<const K, V>, MapKeyOfT>::const_iterator const_iterator;

    iterator begin() { return _t.begin(); }
    iterator end() { return _t.end(); }
    const_iterator begin() const { return _t.begin(); }
    const_iterator   {  .(); }

    V& []( K& key) {
        pair<iterator, > ret = ((key, ()));
         ret.first->second;
    }

    {
         .(kv);
    }
:
    RBTree<K, pair< K, V>, MapKeyOfT> ;
};
}

相关免费在线工具

加密/解密文本
使用加密算法（如AES、TripleDES、Rabbit或RC4）加密和解密文本明文。在线工具，加密/解密文本在线工具，online
Base64 字符串编码/解码
将字符串编码和解码为其 Base64 格式表示形式即可。在线工具，Base64 字符串编码/解码在线工具，online
Base64 文件转换器
将字符串、文件或图像转换为其 Base64 表示形式。在线工具，Base64 文件转换器在线工具，online
Markdown 转 HTML
将 Markdown（GFM）转为 HTML 片段，浏览器内 marked 解析；与 HTML 转 Markdown 互为补充。在线工具，Markdown 转 HTML在线工具，online
HTML 转 Markdown
将 HTML 片段转为 GitHub Flavored Markdown，支持标题、列表、链接、代码块与表格等；浏览器内处理，可链接预填。在线工具，HTML 转 Markdown在线工具，online
JSON 压缩
通过删除不必要的空白来缩小和压缩JSON。在线工具，JSON 压缩在线工具，online

namespace renshen {
template<class K>
class set {
    struct SetKeyOfT {
        const K& operator()(const K& key) {
            return key;
        }
    };
public:
    typedef typename RBTree<K, K, SetKeyOfT>::const_iterator iterator;
    typedef typename RBTree<K, K, SetKeyOfT>::const_iterator const_iterator;

    const_iterator begin() const { return _t.begin(); }
    const_iterator end() const { return _t.end(); }

    pair<iterator, bool> insert(const K& key) {
        pair<typename RBTree<K, K, SetKeyOfT>::iterator, bool> ret = _t.Insert(key);
        return pair<iterator, bool>(ret.first, ret.second);
    }
private:
    RBTree<K, K, SetKeyOfT> _t;
};
}

enum Colour { RED, BLACK };

template<class T>
struct RBTreeNode {
    RBTreeNode<T>* _left;
    RBTreeNode<T>* _right;
    RBTreeNode<T>* _parent;
    T _data;
    Colour _col;

    RBTreeNode(const T& data) : _left(nullptr), _right(nullptr), _parent(nullptr), _data(data), _col(RED) {}
};

template<class K, class T, class KeyOfT>
struct RBTree {
    typedef RBTreeNode<T> Node;
public:
    typedef __TreeIterator<T, T*, T&> iterator;
    typedef __TreeIterator<T, const T*, const T&> const_iterator;

    iterator begin() {
        Node* leftMin = _root;
        while (leftMin && leftMin->_left)
            leftMin = leftMin->_left;
        return iterator(leftMin);
    }

    iterator end() {
        return iterator(nullptr);
    }

    const_iterator begin() const {
        Node* leftMin = _root;
        while (leftMin && leftMin->_left)
            leftMin = leftMin->_left;
        return const_iterator(leftMin);
    }

    const_iterator end() const {
        return const_iterator(nullptr);
    }

    Node* 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 cur;
        }
        return nullptr;
    }

    pair<iterator, bool> Insert(const T& data) {
        if (_root == nullptr) {
            _root = new Node(data);
            _root->_col = BLACK;
            return make_pair(iterator(_root), true);
        }
        Node* parent = nullptr;
        Node* cur = _root;
        KeyOfT kot;
        while (cur) {
            if (kot(cur->_data) < kot(data)) {
                parent = cur;
                cur = cur->_right;
            } else if (kot(cur->_data) > kot(data)) {
                parent = cur;
                cur = cur->_left;
            } else {
                return make_pair(iterator(cur), false);
            }
        }
        cur = new Node(data);
        cur->_col = RED;
        if (kot(parent->_data) < kot(data))
            parent->_right = cur;
        else
            parent->_left = cur;
        cur->_parent = parent;

        while (parent && parent->_col == RED) {
            Node* grandfather = parent->_parent;
            if (parent == grandfather->_left) {
                Node* uncle = grandfather->_right;
                if (uncle && uncle->_col == RED) {
                    parent->_col = uncle->_col = BLACK;
                    grandfather->_col = RED;
                    cur = grandfather;
                    parent = cur->_parent;
                } else {
                    if (cur == parent->_left) {
                        RotateR(grandfather);
                        parent->_col = BLACK;
                        grandfather->_col = RED;
                    } else {
                        RotateL(parent);
                        RotateR(grandfather);
                        cur->_col = BLACK;
                        grandfather->_col = RED;
                    }
                    break;
                }
            } else {
                Node* uncle = grandfather->_left;
                if (uncle && uncle->_col == RED) {
                    parent->_col = uncle->_col = BLACK;
                    grandfather->_col = RED;
                    cur = grandfather;
                    parent = cur->_parent;
                } else {
                    if (cur == parent->_right) {
                        RotateL(grandfather);
                        grandfather->_col = RED;
                        parent->_col = BLACK;
                    } else {
                        RotateR(parent);
                        RotateL(grandfather);
                        cur->_col = BLACK;
                        grandfather->_col = RED;
                    }
                    break;
                }
            }
        }
        _root->_col = BLACK;
        return make_pair(iterator(cur), true);
    }

private:
    Node* _root = nullptr;
};

template<class T, class Ptr, class Ref>
struct __TreeIterator {
    typedef RBTreeNode<T> Node;
    typedef __TreeIterator<T, Ptr, Ref> Self;
    typedef __TreeIterator<T, T*, T&> Iterator;

    __TreeIterator(const Iterator& it) : _node(it._node) {}
    Node* _node;

    __TreeIterator(Node* node) : _node(node) {}

    Ref operator*() { return _node->_data; }
    Ptr operator->() { return &_node->_data; }

    bool operator!=(const Self& s) const { return _node != s._node; }
    bool operator==(const Self& s) const { return _node == s._node; }

    Self& operator--() {
        if (_node->_left) {
            Node* subRight = _node->_left;
            while (subRight->_right)
                subRight = subRight->_right;
            _node = subRight;
        } else {
            Node* cur = _node;
            Node* parent = cur->_parent;
            while (parent && cur == parent->_left) {
                cur = cur->_parent;
                parent = parent->_parent;
            }
            _node = parent;
        }
        return *this;
    }

    Self& operator++() {
        if (_node->_right) {
            Node* subLeft = _node->_right;
            while (subLeft->_left)
                subLeft = subLeft->_left;
            _node = subLeft;
        } else {
            Node* cur = _node;
            Node* parent = cur->_parent;
            while (parent && cur == parent->_right) {
                cur = cur->_parent;
                parent = parent->_parent;
            }
            _node = parent;
        }
        return *this;
    }
};

STL 底层剖析：map/set 如何封装红黑树及迭代器实现

map 和 set 的封装

更多推荐文章

相关免费在线工具

底层红黑树的模拟实现

迭代器的模拟实现

STL 底层剖析：map/set 如何封装红黑树及迭代器实现

map 和 set 的封装

微信扫一扫，关注极客日志

更多推荐文章

相关免费在线工具

底层红黑树的模拟实现

迭代器的模拟实现