set 和 map

---

set 和 multiset

set

• set 类的介绍

  set 是基于红黑树实现的有序容器。它的插入、删除、查找操作的时间复杂度均为 O(log n)。遍历时，set 的迭代器按照中序遍历，因此它总是以升序排列元素。

  • set 的声明如下，T 表示 set 的关键字类型：

  template <class T,            // set::key_type/value_type
            class Compare = less<T>, // set::key_compare/value_compare
            class Alloc = allocator<T> // set::allocator_type
  > class set;
  

set 的构造和迭代器

• set 支持正向和反向迭代遍历，默认以升序排列。由于底层是二叉搜索树，迭代器遍历是中序遍历。set 的 iterator 和 const_iterator 均不支持修改数据，修改关键字会破坏底层搜索树的结构。

// 无参默认构造，创建一个空的 set 容器
explicit set (const key_compare& comp = key_compare(),
              const allocator_type& alloc = allocator_type());

// 迭代器区间构造，使用 [first, last) 范围的元素创建 set 容器
template <class InputIterator>
set (InputIterator first, InputIterator last,
     const key_compare& comp = key_compare(),
     const allocator_type& = allocator_type());

// 拷贝构造
set (const set& x);

// initializer 列表构造，使用初始化列表创建 set 容器
set (initializer_list<value_type> il,
     const key_compare& comp = key_compare(),
     const allocator_type& alloc = allocator_type());

// 双向迭代器
iterator -> bidirectional iterator to const value_type

// 正向迭代器
iterator begin();
iterator end();

// 反向迭代器
reverse_iterator rbegin();
reverse_iterator rend();

set 的增删查操作

// 列表插入，已存在的值不会再次插入
void insert (initializer_list<value_type> il);

// 迭代器区间插入，已存在的值不会再次插入
template <class InputIterator>
void insert (InputIterator first, InputIterator last);

// 查找 val，返回对应的迭代器，没有找到则返回 end()
iterator find (const value_type& val);

// 返回 val 的个数，set 中最多返回 1（因为 set 不允许重复）
size_type count (const value_type& val) const;

// 删除指定位置的元素
iterator erase (const_iterator position);

// 删除值为 val 的元素，成功返回 1，失败返回 0
size_type erase (const value_type& val);

// 删除一段迭代器区间内的元素
iterator erase (const_iterator first, const_iterator last);

// 返回大于等于 val 的第一个位置的迭代器
iterator lower_bound (const value_type& val) const;

// 返回大于 val 的第一个位置的迭代器
iterator upper_bound (const value_type& val) const;

multiset 和 set 的区别

multiset 和 set 的使用方式几乎完全相同，最大的区别在于 multiset 支持存储重复值，而 set 不允许重复值的存在。

例如，使用 multiset 允许多次插入相同的元素，而 set 在多次插入相同的元素时，只会保留一个元素。

• multiset 示例：

std::multiset<int> ms;
ms.insert(5);
ms.insert(5);
std::cout << ms.count(5); // 输出 2，因为 multiset 允许存储重复值

• multiset 删除操作：

// 删除 multiset 中所有等于 5 的元素
ms.erase(5);

总结

• set 中的元素是唯一的，不允许重复元素的插入。
• multiset 支持存储重复元素，因此可以多次插入相同的值。
• 二者底层均基于红黑树实现，操作复杂度都是 O(log n)。区别在于 set 强制唯一性，而 multiset 则允许重复。

---

map 和 multimap

• map 类的介绍

  map 的声明如下，Key 就是 map 底层关键字的类型，T 是 map 底层 value 的类型，set 默认要求 Key 支持小于比较，如果不支持或者需要的话可以自行实现仿函数传给第二个模版参数，map 底层存储数据的内存是从空间配置器申请的。一般情况下，我们都不需要传后两个模版参数。map 底层是用红黑树实现，增删查改效率是 ，迭代器遍历是走 O(logN) 的中序，所以是按 key 有序顺序遍历的。

  template < class Key, // map::key_type
  class T, // map::mapped_type
  class Compare = less<Key>, // map::key_compare
  class Alloc = allocator<pair<const Key,T> > //
  map::allocator_type
  > class map;
  

  • pair 类型介绍

    map 底层的红黑树节点中的数据，使用 pair<Key, T>存储键值对数据。

    typedef pair<const Key, T> value_type;
    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)
            {
            }
            template <class U, class V>
            pair(const pair<U, V> &pr) : first(pr.first), second(pr.second)
            {
            }
        };
        template <class T1, class T2>
        inline pair<T1, T2> make_pair(T1 x, T2 y)
        {
            return (pair<T1, T2>(x, y));
        }
    
    

• map 的构造

  map 的支持正向和反向迭代遍历，遍历默认按 key 的升序顺序，因为底层是二叉搜索树，迭代器遍历走的中序；支持迭代器就意味着支持范围 for，map 支持修改 value 数据，不支持修改 key 数据，修改关键字数据，破坏了底层搜索树的结构。

  // empty (1) 无参默认构造
  explicit map (const key_compare& comp = key_compare(),
  const allocator_type& alloc = allocator_type());
  
  // range (2) 迭代器区间构造
  template <class InputIterator>
  map (InputIterator first, InputIterator last,
  const key_compare& comp = key_compare(),
  const allocator_type& = allocator_type());
  
  // copy (3) 拷贝构造
  map (const map& x);
  
  // initializer list (5) initializer 列表构造
  map (initializer_list<value_type> il,
  const key_compare& comp = key_compare(),
  const allocator_type& alloc = allocator_type());
  
  // 迭代器是一个双向迭代器
  iterator -> a bidirectional iterator to const value_type
  
  // 正向迭代器
  iterator begin();
  iterator end();
  // 反向迭代器
  reverse_iterator rbegin();
  reverse_iterator rend();
  

• map 的增删查

  map 增接口，插入的 pair 键值对数据，跟 set 所有不同，但是查和删的接口只用关键字 key 跟 set 是完全类似的，不过 find 返回 iterator，不仅仅可以确认 key 在不在，还找到 key 映射的 value，同时通过迭代还可以修改 value

  Member types
  key_type -> The first template parameter (Key)
  mapped_type -> The second template parameter (T)
  value_type -> pair<const key_type,mapped_type>
  // 单个数据插入，如果已经key存在则插入失败,key存在相等value不相等也会插入失败
  pair<iterator,bool> insert (const value_type& val);
  
  // 列表插入，已经在容器中存在的值不会插入
  void insert (initializer_list<value_type> il);
  
  // 迭代器区间插入，已经在容器中存在的值不会插入
  template <class InputIterator>
  void insert (InputIterator first, InputIterator last);
  
  // 查找k，返回k所在的迭代器，没有找到返回end()
  iterator find (const key_type& k);
  
  // 查找k，返回k的个数
  size_type count (const key_type& k) const;
  
  // 删除一个迭代器位置的值
  iterator erase (const_iterator position);
  
  // 删除k，k存在返回0，存在返回1
  size_type erase (const key_type& k);
  
  // 删除一段迭代器区间的值
  iterator erase (const_iterator first, const_iterator last);
  
  // 返回大于等k位置的迭代器
  iterator lower_bound (const key_type& k);
  
  // 返回大于k位置的迭代器
  const_iterator lower_bound (const key_type& k) const;
  
  

• multimap 和 map 的差异

  multimap 和 map 的使用基本完全类似，主要区别点在于 multimap 支持关键值 key 冗余，那么insert/find/count/erase 都围绕着支持关键值 key 冗余有所差异，这里跟 set 和 multiset 完全一样，比如 find 时，有多个 key，返回中序第一个。其次就是 multimap 不支持[]，因为支持 key 冗余，[]就只能支持插入了，不能支持修改。