multiset如何存储重复元素？ 我知道，在C++中，SET模板将元素存储为平衡的红黑树。但我想知道multiset如何存储重复元素。例如，它可以按如下方式存储1,1,2,3 1 / \ 1 2 \ 3

或作为

---

标准库的合理实现将有一个数据结构来实现

map

、

multimap

、

set

和

multiset

中的所有四个。公共成员之间的差异归结为“我们如何比较

值类型

实例？”“重复

插入

的结果是什么？”

由于复杂性的要求，它通常是一个平衡的二叉树

作为如何调整

平衡树的示意图：

template <typename Value, typename Compare, typename Allocator>
class BalancedTree { ... };

template<
    class Key,
    class T,
    class Compare = std::less<Key>,
    class Allocator = std::allocator<std::pair<const Key, T> >
> class map
{
public:
  using value_type = std::pair<const Key, T>;
  class value_compare 
  { 
    value_compare(Compare c) : c(c) {}
    bool operator()( const value_type& lhs, const value_type& rhs ) const
    {
      return c(lhs.first, rhs.first);
    }
    Compare c;
  }

  std::pair<iterator, bool> insert(value_type vt)
  {
    node n(vt);
    auto pos = bt.insert_point(n);
    if (value_comp()(*pos, vt))
      return { bt.splice(pos, n), true };
    return { pos, false };
  }

private:
  BalancedTree<value_type, value_compare, Allocator> bt;
}

template<
    class T,
    class Compare = std::less<T>,
    class Allocator = std::allocator<T>
> class multi_set
{
public:
  using value_type = T;
  iterator insert(value_type vt)
  {
    node n(vt);
    auto pos = bt.insert_point(n);
    return bt.splice(pos, n);
  }

private:
  BalancedTree<T, Compare, Allocator> bt;
}

模板
类平衡树{…}；
模板<
类密钥，
T类，
类比较=标准：：更少，
类分配器=std:：分配器
>类图
{
公众：
使用value_type=std:：pair；
类值比较
{ 
值_比较（比较c）：c（c）{
布尔运算符（）（常量值类型和lhs、常量值类型和rhs）常量
{
返回c（左首，右首）；
}
比较c；
}
标准：：对插入（值\类型vt）
{
节点n（vt）；
自动位置=bt.insert_点（n）；
如果（值_comp（）（*pos，vt））
返回{bt.splice（pos，n），true}；
返回{pos，false}；
}
私人：
平衡树bt；
}
模板<
T类，
类比较=标准：：更少，
类分配器=std:：分配器
>类多重集合
{
公众：
使用值_type=T；
迭代器插入（值类型vt）
{
节点n（vt）；
自动位置=bt.insert_点（n）；
返回bt接头（位置n）；
}
私人：
平衡树bt；
}
检查库的源代码。map和set的内部不是固定的，但传统的实现是一个平衡的红黑树。@Ron但这会使迭代器的实现比允许倍数更困难。@Ron我认为它们存储为树。可能是唯一元素的红黑树，其列表附加到任何具有重复项的节点。但只要满足时间限制，实现就可以随心所欲。您需要查看实现的源代码。
template <typename Value, typename Compare, typename Allocator>
class BalancedTree { ... };

template<
    class Key,
    class T,
    class Compare = std::less<Key>,
    class Allocator = std::allocator<std::pair<const Key, T> >
> class map
{
public:
  using value_type = std::pair<const Key, T>;
  class value_compare 
  { 
    value_compare(Compare c) : c(c) {}
    bool operator()( const value_type& lhs, const value_type& rhs ) const
    {
      return c(lhs.first, rhs.first);
    }
    Compare c;
  }

  std::pair<iterator, bool> insert(value_type vt)
  {
    node n(vt);
    auto pos = bt.insert_point(n);
    if (value_comp()(*pos, vt))
      return { bt.splice(pos, n), true };
    return { pos, false };
  }

private:
  BalancedTree<value_type, value_compare, Allocator> bt;
}

template<
    class T,
    class Compare = std::less<T>,
    class Allocator = std::allocator<T>
> class multi_set
{
public:
  using value_type = T;
  iterator insert(value_type vt)
  {
    node n(vt);
    auto pos = bt.insert_point(n);
    return bt.splice(pos, n);
  }

private:
  BalancedTree<T, Compare, Allocator> bt;
}