map和set的使用以及模拟实现

最新推荐文章于 2025-07-01 18:56:27 发布
原创 最新推荐文章于 2025-07-01 18:56:27 发布 · 1.1k 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#数据结构

本文详细介绍了STL中set和map容器的特性与接口使用方法，并通过代码示例展示了如何进行元素插入、查找和删除等操作。同时，还探讨了set与map底层实现原理，包括红黑树的数据结构。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

1,set
我们先来看看STL中set的接口有哪些
这里写图片描述
这里写图片描述

set的底层使用红黑树来实现，红黑树是一个不暴露给外界的数据结构，map和set都用它来实现，所以map和set是属于关联式容器。

set的特性:
所有的元素都会根据元素的键值自动排序，set的元素不像map那样可以同时拥有实值（value）和键值（key）,set元素的键值就是实值，实值就是键值，set不允许两个元素有相同的键值。
我们不可以通过set的迭代器来改变set的元素值，因为其元素值就是键值，关系到set元素的排列规则。因此，在STL中set的迭代器底层是rb_tree的const_iterator.

以下是对set部分接口的使用：

#include<set>
#include<iostream>
using namespace std;

void Test()
{
    set<int> s;
    int a[10] = { 10, 9, 8, 5, 4, 2, 1, 3, 7, 6 };
    for (size_t i = 0; i < 10; i++)
    {
        s.insert(a[i]);
    }
    set<int>::iterator it1 = s.begin();
    while (it1 != s.end())
    {
        cout << *it1 << " ";
        ++it1;
    }
    cout << endl;
    cout << "Size = " << s.size() << endl;
    cout << "3 Count = " << s.count(3) << endl;
    s.insert(5);
    cout << "Size = " << s.size() << endl;
    s.insert(11);
    cout << "Size = " << s.size() << endl;
    set<int>::iterator it2 = s.begin();
    while (it2 != s.end())
    {
        cout << *it2 << " ";
        ++it2;
    }
    cout << endl;
    s.erase(2);
    set<int>::iterator it3 = s.begin();
    while (it3 != s.end())
    {
        cout << *it3<< " ";
        ++it3;
    }
    cout << endl;
}

这里写图片描述
由以上打印结果，我们可以看出，set中的insert使用的是rb_tree的insert_unique(),而不是insert_equal(),因为set不允许相同键值存在，multiset才允许相同键值存在。

2，map
先来看map的接口
这里写图片描述
这里写图片描述
font size=4 color=#8B008B>map的特性:
所有元素都会根据元素的键值自动被排序，map的所有元素都是pair,同时拥有实值（value）和键值（key）。pair的第一个元素被视为键值，第二个元素被视为实值。map不允许两个元素拥有相同的键值。
pair的定义如下：

template<class T1,class T2>
struct pair
{
    typedef T1 first_type;
    typedef T2 second_type;

    T1 first;
    T2 second;
    pair()
        :first(T1())
        ,second(T2())
    {}

    pair(const T1& a, const T2& b)
        :first(a)
        ,second(b)
    {}
};

为什么要有pair呢？
因为map是K,V模型，而一个函数不能有两个返回值，要返回两个值需要返回一个结构体，pair就是这个要返回的结构体。

map的键值（key）不能被修改，但实值（value）可以修改.
我们来简单使用以下map的部分接口：

void Test()
{
    map<string, int> p;
    p[string("liuyulin")] = 1;
    p[string("zhangyuhao")] = 2;
    p[string("cuicui")] = 3;
    p[string("yuxi")] = 4;

    pair<string, int> value(string("daiwei"), 5);
    p.insert(value);

    map<string, int>::iterator it = p.begin();
    while (it != p.end())
    {
        cout << it->first << ":" << it->second << endl;
        ++it;
    }

    int num = p[string("liuyulin")];
    cout << num << endl;

    map<string, int>::iterator it1;
    it1 = p.find(string("zhangyuhao"));
    if (it1 == p.end())
    {
        cout << "zahngyuhao found" << endl;
    }
    it1->second = 6;//可以修改second的值
    int num2 = p["zhangyuhao"];
    cout << num2 << endl;
}

这里写图片描述

map中的make_pair返回一个pair对象。

tempalate<class K,class V>
inline pair<k,v>make_pair(const K& key,const V& value)
{
return pair<k,v>(key,value);//类型推演
}

我们再来介绍map的operator[]：

typedef Key key_value;
typedef pair<const Key,T> value_type;
T& operator[](const key_type& k)
{
return (*((insert(value_type(k,T()))).first)).second;
}

首先，根据类型推演产生一个临时对象value_type(k,T())
再将该元素插入到map中

insert(value_type(k,T())

插入操作返回一个pair，其第一个元素是个迭代器，指向插入妥当的新元素，或指向插入失败点（键值重复）的旧元素。

（insert（value_type（k,T()）））.first

取迭代器中的第二个元素，是个bool值

(*((insert(value_type(k,T()))).first)).second;

关于map的一道面试题:
统计公司员工最喜欢吃的前K中水果

map<string,int>countMap;
string str[] = {"苹果","香蕉","橘子","苹果"，"橘子"};
for(size_t i = 0;i<sizeof(str)/sizof(str[0]);++i)
{
   map<string,int>::iterator it = countMap.find(str[i]);
  (1)if(it != countMap.end())//说明已经有这种水果了
  {
     it->second++;
  }
   else
  {
   (2)//countMap.insert(pair<string,int>(str[i],1));
    countMap.insert(make_pair(s[i],1);//make_pair是一个模板函数
  }
   (3)//countMap[str[i]]++;
}

下面我们来简单模拟map和set的部分接口的实现。
由于它们底层都是红黑树，所以我们对之前红黑树的代码做部分调整即可。需要清楚的是：set的value_type是K类型，而map的value_type是pair类型。

rb_tree.h

#pragma once
#include<iostream>
using namespace std;

enum Colour
{
    RED,
    BLACK,
};

template<class ValueType>
struct RBTreeNode
{
    ValueType _valueField;

    RBTreeNode<ValueType>* _left;
    RBTreeNode<ValueType>* _right;
    RBTreeNode<ValueType>* _parent;

    Colour _col;

    RBTreeNode(const ValueType& v)
        :_valueField(v)
        , _left(NULL)
        , _right(NULL)
        , _parent(NULL)
        , _col(RED)
    {}
};

//map返回pair
//set返回K
template<class ValueType>
struct __TreeIterator
{
    typedef RBTreeNode<ValueType>Node;
    typedef __TreeIterator<ValueType> Self;
    Node* _node;

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

    ValueType& operator*()
    {
        return _node->_valueField;
    }

    ValueType* operator->()
    {
        return &(_node->_valueField);
    }

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

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

    Self& operator++()//前置++
    {
        if (_node->_right)
        {
            Node* SubRight = _node->_right;
            while (SubRight->_left)
            {
                //访问右子树的最左节点
                SubRight = SubRight->_left;
            }
            _node = SubRight;
        }
        else
        {
            Node* cur = _node;
            Node* parent = cur->_parent;
            while(parent && cur == parent->_right)
            {
                cur = parent;
                parent = cur->_parent;
            }
            _node = parent;
        }
        return *this;
    }

    Self operator++(int)//后置++
    {
        Self tmp(*this);
        ++tmp;
        return *this;
    }

    Self& operator--()
    {
        if (_node->_left)
        {
            Node* Subleft = _node->_left;
            while (Subleft->_right)
            {
                //左子树的最右节点
                Subleft = Subleft->_right;
            }
            _node = Subleft;
        }
        else
        {
            Node* cur = _node;
            Node* parent = cur->_parent;
            while (parent && cur == parent->_left)
            {
                cur = parent;
                parent = cur->_parent;
            }
            _node = parent;
        }
        return *this;
    }

    Self operator--(int)
    {
        Self tmp(*this);
        --tmp;
        return *this;
    }

};


template<class K,class V,class KeyOfValue>
class RBTree
{
    typedef V ValueType;
    typedef RBTreeNode<ValueType> Node;
public:
    typedef __TreeIterator<ValueType> Iterator;
    RBTree()
        :_root(NULL)
    {}

    RBTree(const RBTree<K, V,KeyOfValue>& tree)
    {
        _Copy(tree._root);
    }


    ~RBTree()
    {
        _Destroy(_root);
    }

    RBTree<K, V,KeyOfValue>& operator = (const RBTree<K, V,KeyOfValue>& tree)
    {
        RBTree<K, V,KeyOfValue> tmp(tree);
        swap(_root, tree._root);
        return *this;
    }

    Iterator Begin()
    {
        Node* cur = _root;
        while (cur && cur->_left)
        {
            cur = cur->_left;
        }
        return cur;//单参数的构造函数允许隐式类型转换
    }

    Iterator End()
    {
        return NULL;
    }

    Iterator ReBegibn()
    {
        Node* cur = _root;
        while (cur->_right)
        {
            cur = cur->_right;
        }
        return cur;
    }

    Iterator ReEnd()
    {
        return NULL;
    }


    pair<Iterator,bool> Insert(const ValueType& v)
    {
        if (_root == NULL)
        {
            _root = new Node(v);
            _root->_col = BLACK;
            return make_pair(Iterator(_root),true);
        }

        KeyOfValue keyOfValue;
        Node* parent = NULL;
        Node* cur = _root;
        while (cur)
        {
            if (keyOfValue(cur->_valueField)  < keyOfValue(v))
            {
                parent = cur;
                cur = cur->_right;
            }
            else if (keyOfValue(cur->_valueField) > keyOfValue(v))
            {
                parent = cur;
                cur = cur->_left;
            }
            else
            {
                return make_pair(Iterator(cur),false);
            }
        }
        Node* newNode = cur;
        cur = new Node(v);
        if (keyOfValue(parent->_valueField) < keyOfValue(v))
        {
            parent->_right = cur;
            cur->_parent = parent;
        }
        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 = BLACK;
                    uncle->_col = BLACK;
                    grandfather->_col = RED;

                    cur = grandfather;
                    parent = cur->_parent;
                }
                else // u 不存在 u黑
                {
                    if (cur == parent->_right) // 双旋
                    {
                        RotateL(parent);
                        swap(cur, parent);
                    }

                    RotateR(grandfather);
                    parent->_col = BLACK;
                    grandfather->_col = RED;
                    break;
                }
            }
            //parent = grandfather->right
            else if (parent == grandfather->_right)
            {
                Node* uncle = grandfather->_left;
                if (uncle && uncle->_col == RED)
                {
                    parent->_col = BLACK;
                    uncle->_col = BLACK;
                    grandfather->_col = RED;

                    cur = grandfather;
                    parent = cur->_parent;
                }
                else
                {
                    if (cur == parent->_right)
                    {
                        RotateR(parent);
                        swap(parent, cur);
                    }
                    RotateL(grandfather);
                    parent->_col = BLACK;
                    grandfather->_col = RED;
                    break;
                }
            }
        }
        _root->_col = BLACK;
        return make_pair(Iterator(newNode),true);
    }

    void InOrder()
    {
        _InOrder(_root);
    }

protected:
    void _Copy(Node* root)
    {
        Node* newNode = NULL;
        Node* cur = root;
        while (cur)
        {
            newNode = new Node(cur->_key, cur->_value);
            newNode->_left = _Copy(cur->_left);
            newNode->_right = _Copy(cur->_right);
        }
    }

    void _Destroy(Node* root)
    {
        Node* cur = root;
        if (root == NULL)
            return;
        _Destroy(cur->_left);
        _Destroy(cur->_right);
        delete cur;
        cur = NULL;
    }

    Iterator Find(const K& key)
    {
        KeyOfValue keyOfValue;
        Node* cur = _root;
        while (cur)
        {
            if (keyOfValue(cur->_valueField) > key)
            {
                cur = cur->_left;
            }
            else if (keyOfValue(cur->_valueField) < key)
            {
                cur = cur->_right;
            }
            else
            {
                return cur;
            }
        }
        return Iterator(NULL);
    }

    //右旋
    void RotateR(Node* parent)
    {
        Node* subL = parent->_left;
        Node* subLR = subL->_right;
        parent->_left = subLR;
        if (subLR)
            subLR->_parent = parent;

        subL->_right = parent;
        Node* ppNode = parent->_parent;
        parent->_parent = subL;

        if (ppNode == NULL)
        {
            _root = subL;
            subL->_parent = NULL;
        }
        else
        {
            if (ppNode->_left == parent)
            {
                ppNode->_left = subL;
            }
            else
            {
                ppNode->_right = subL;
            }
            subL->_parent = ppNode;
        }
    }

    //左旋
    void RotateL(Node* parent)
    {
        Node* subR = parent->_right;
        Node* subRL = subR->_left;

        parent->_right = subRL;
        if (subRL)
            subRL->_parent = parent;

        subR->_left = parent;
        Node* ppNode = parent->_parent;
        parent->_parent = subR;

        if (ppNode == NULL)
        {
            _root = subR;
            subR->_parent = NULL;
        }
        else
        {
            if (ppNode->_left == parent)
            {
                ppNode->_left = subR;
            }
            else
            {
                ppNode->_right = subR;
            }
            subR->_parent = ppNode;
        }
    }

    void _InOrder(Node* root)
    {
        Node* cur = root;
        if (cur == NULL)
            return;
        _InOrder(cur->_left);
        cout << cur->_valueField<< " ";
        _InOrder(cur->_right);
    }
private:
    Node* _root;
};

myset.h

#pragma once
#include"rbtree.h"

template<class K>
class Set
{
public:
    struct KeyOfValue
    {
        const K& operator()(const K& k)
        {
            return k;
        }
    };

    //typename是告诉编译器在实例化的时候确定类型，延迟确认
    typedef typename RBTree<K, K,KeyOfValue>::Iterator Iterator;
    pair<Iterator, bool> InSert(const K& key)
    {
        return _tree.Insert(key);
    }

    Iterator Begin()
    {
        return _tree.Begin();
    }

    Iterator End()
    {
        return _tree.End();
    }

    Iterator ReBegin()
    {
        return _tree.ReBegibn();
    }

    Iterator ReEnd()
    {
        return _tree.ReEnd();
    }

    void InOrder()
    {
        _tree.InOrder();
    }
private:
    RBTree<K, K,KeyOfValue> _tree;
};

void TestSet()
{
    Set<int> s;
    s.InSert(10);
    s.InSert(15);
    s.InSert(12);
    s.InSert(11);
    s.InSert(13);
    s.InSert(14);
    s.InSert(16);

    Set<int>::Iterator it = s.Begin();
    while (it != s.End())
    {
        cout << *it << " ";
        ++it;
    }
    cout << endl;
}

这里写图片描述

mymap.h

#pragma once
#include"rbtree.h"
#include<string>

template<class K,class V>
class Map
{
public:
    typedef pair<K, V> ValueType;

    struct KeyOfValue
    {
        const K& operator()(const ValueType& kv)
        {
            return kv.first;
        }
    };

    typedef typename RBTree<K, ValueType, KeyOfValue>::Iterator Iterator;
    pair<Iterator, bool>InSert(const ValueType& v)
    {
        return _tree.Insert(v);
    }

    Iterator Begin()
    {
        return _tree.Begin();
    }

    Iterator End()
    {
        return _tree.End();
    }

    void InOrder()
    {
        _tree.InOrder();
    }
private:
    RBTree<K, ValueType,KeyOfValue>_tree;
};

void TestMap()
{
    Map<string, string> dict;
    dict.InSert(make_pair("sort", "排序"));
    dict.InSert(make_pair("insert", "插入"));
    dict.InSert(make_pair("left", "左边"));
    dict.InSert(make_pair("right", "右边"));
    Map<string, string>::Iterator it = dict.Begin();
    while (it != dict.End())
    {
        cout << it->first << ":" << it->second <<endl;
        ++it;
    }
    cout << endl;
}

这里写图片描述

multiset和multimap
multiset的特性以及用法和set完全相同，唯一的差别在于它允许键值重复，因此它的插入操作采用的底层机制是RB_Tree的insert_equal,而非insert_unique.

void TestSet()
{
    int a[] = { 1, 2, 2, 3, 4, 4 };
    set<int> s;
    for (size_t i = 0; i < sizeof(a) / sizeof(a[0]); ++i)
    {
        s.insert(a[i]);
    }
    set<int>::iterator it1 = s.begin();
    cout << "set:";
    while (it1 != s.end())
    {
        cout << *it1 << " ";
        ++it1;
    }
    cout << endl;

    multiset<int> ms;
    for (size_t i = 0; i < sizeof(a) / sizeof(a[0]); ++i)
    {
        ms.insert(a[i]);
    }
    multiset<int>::iterator it2 = ms.begin();
    cout << "multiset:";
    while (it2 != ms.end())
    {
        cout << *it2 << " ";
        ++it2;
    }
    cout << endl;
}

用上述代码对比二者的打印结果即可：
这里写图片描述

mutilmap的特性和用法和map也是完全相同，唯一的区别就在于它允许键值冗余，因此它的插入的底层机制采用RB_Tree的insert_equal.同样用代码来看效果.
这里写图片描述

map和set
h1091068389的博客
05-29 576
map和set关联式容器setset模板参数列表set的构造set的迭代器set容量操作set增删查改inserterasefindmultiset注意事项mapmap的模板参数map的构造map的迭代器map的容量操作map的增删查改 关联式容器 STL中容器一般可以分为两类，一类是以vector、list、deque等为代表的序列式容器，他的特点是其底层为线性序列的数据结构，里面存储的是元素本身。还有一种是关联式容器，他也是用来存储数据的，但是和序列式容器的区别在于它里面存放的是<key,valu
C++：map和set的使用
Makise的博客
09-02 1119
一篇带你完全掌握set和map的使用
Map与Set
weixin_45737168的博客
08-18 280
Map与Set属于动态查找，作用是用来帮助用户进行搜索的容器。 Map Map是一个接口，没有继承Collection Map中存储的是一个k-v键值对，一个映射不能包含重复的键；每个键最多只能映射到一个值，即k值唯一且不能为空。 所谓的k-v结构实际上是在Map中定义了一个内部类**Entry**，该类的作用就是存放<key,value>键值对的映射关系。它所具有的方法如下： Map中常用的方法： 注意： 1、Map是一个接口，不能直接实例化对象，如果要实例化对象只能通过其实现类Tre
Set和Map的解析与应用场景
最新发布
记录来时的路
07-01 962
ES6引入的Set和Map为JavaScript提供了更高效的数据结构。Set存储唯一值，适用于数组去重、快速存在性检查等场景，其has()方法效率远高于数组。Map支持任意类型键值对，维护插入顺序，适合对象键存储、缓存和频率计数等需求。与普通对象相比，Set和Map具有更严格的唯一性判断、有序迭代和高效操作等优势。选择使用时：需要唯一值集合选Set；需要灵活键值对且维护顺序选Map；仅字符串键且不关心顺序可用普通对象。两者都填补了传统数组和对象的局限性，提供了更专业的解决方案。
STL之树形结构的关联式容器
bkf136114378的博客
08-21 764
STL中有很多的容器比如说序列是容器和关联式容器，经常见到的容器有这些：vector，list，deque，forward_lise等，这几个容器通常称为序列式容器，因为其底层为线性序列的数据结构，里面存储的是元素本身。 什么是关联是容器？ 关联式容器也是用来存储数据的，与序列式容器不同的是，其里面存储的是<key,value>结构的键值对，在数据检索的时候比序列式容器效率更高。 ...
map和set的初步了解
wnx_hh的博客
06-13 317
STL容器大致分为两类，一类是序列式容器，一类是关联式容器。比如：vector list deque forward_list等，这些容器统称为序列式容器，因为其底层为线性序列的数据结构，里面存储的是元素本身。 序列式容器 所谓序列容器即容器其中的元素都可序，但未必有序。常见的序列容器包括vector,list,deque,queue以及stack。 关联式容器 关联式容器也是用来存储数据的，与序列式容器不同的是，其里面存储的是<key, value>结构的键值对，在数据检索时比序列式容器效率更
map和set的模拟实现
06-06
在IT领域，数据结构是编程的基础，...总之，通过封装红黑树并结合C++的面向对象特性，我们可以构建出高性能的Map和Set模拟实现。这不仅可以加深对数据结构和算法的理解，也有助于在实际项目中构建高效的数据处理机制。
unordered_map和unordered_set的模拟实现
01-20
unordered_map和unordered_set的模拟实现 （一）哈希表的特性及概念 定义： 哈希表（Hash table，也叫散列表），是根据关键字值（key,value）直接进行访问的数据结构。也就是说，它通过把关键字映射到表中一个位置来...
C++：set和map的底层封装模拟实现
2301_76445610的博客
05-17 1261
底层对比：上图以kv模型为例。
Map 和 Set
Excuse_lighttime的博客
02-15 4551
Map 和 Set
Map和Set
a13572259715的博客
05-18 401
文章目录一、搜索1.概念和背景2.模型二、Map的使用1.关于Map的使用说明2.关于Map.Entry 一、搜索 1.概念和背景 Map和Set是一种专门用来进行搜索的容器或者数据结构，其搜索效率与具体的实例化子类有关 我们之前常见的搜索方式有： (1)直接遍历，时间复杂度O(n)，元素如果比较多效率会比较慢 (2)二分查找，时间复杂度为O(log2(n))但搜索前必须要求序列是有序的 2.模型 一般搜索的数据称为关键字（Key）,和关键字对应的称为值（Value），将其称之为Key-Value的键值..
map与set
逆水行舟 不进则退
03-08 514
7-11 悄悄关注（25 分） 新浪微博上有个“悄悄关注”，一个用户悄悄关注的人，不出现在这个用户的关注列表上，但系统会推送其悄悄关注的人发表的微博给该用户。现在我们来做一回网络侦探，根据某人的关注列表和其对其他用户的点赞情况，扒出有可能被其悄悄关注的人。 输入格式： 输入首先在第一行给出某用户的关注列表，格式如下： 人数N 用户1 用户2 …… 用户N 其中N是不超过
C++红黑树封装实现map和set模拟
本资源将通过封装红黑树来模拟实现map和set。红黑树是一种自平衡的二叉搜索树，通过对插入和删除操作的特定处理，它可以保证最坏情况下的时间复杂度为O(log n)，这对于需要高效搜索和插入操作的场景非常有用。 在...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值