如何根据 std::map 的值获取前 n 个键？

Posted 2023-02-22

【中文标题】如何根据 std::map 的值获取前 n 个键？

【英文标题】：How can i get the top n keys of std::map based on their values?

【发布时间】：2013-07-31 07:13:55

【问题描述】：

如何根据值获取 std::map 的前 n 个键？ 有没有一种方法可以让我得到一个列表，例如前 10 个键值最大的键值？ 假设我们有一张类似这样的地图：

mymap["key1"]= 10;
mymap["key2"]= 3;
mymap["key3"]= 230;
mymap["key4"]= 15;
mymap["key5"]= 1;
mymap["key6"]= 66;
mymap["key7"]= 10; 

我只想列出前 10 个键的列表，这些键与其他键相比具有更大的价值。 例如，我们的 mymap 的前 4 名是

key3
key6
key4 
key1
key10 

注意： 这些值不是唯一的，实际上它们是每个键的出现次数。我想得到一个最常出现的键的列表

注 2： 如果 map 不是一个好的候选人，你想建议什么，请按照 c++11 做，我当时不能使用 boost。

注3： 如果使用std::unordered_multimap<int,wstring>，我还有其他选择吗？

【问题讨论】：

也许 std::map 不是你想要的。

Boost.Bimap 允许你使用值类型作为键

c++ - Tricky Method - need solution 和 map operations(find most occurence element) 等可能重复

对此有任何 c++11 解决方案吗？我当时不能使用 boost

【参考方案1】：

map 的顺序是基于它的键而不是它的值，并且不能重新排序，因此有必要遍历 map 并维护遇到的前十名或Potatoswatter 评论的列表使用 partial_sort_copy() 为您提取前 N 个值：

std::vector<std::pair<std::string, int>> top_four(4);
std::partial_sort_copy(mymap.begin(),
                       mymap.end(),
                       top_four.begin(),
                       top_four.end(),
                       [](std::pair<const std::string, int> const& l,
                          std::pair<const std::string, int> const& r)
                       
                           return l.second > r.second;
                       );

见online demo。

选择不同类型的容器可能更合适，boost::multi_index 值得研究，其中：

... 支持构建容器，维护一个或多个具有不同排序和访问语义的索引。

【讨论】：

使用std::partial_sort_copy可以省去迭代和保持top N的手动工作。

实际上再三考虑，我认为警告甚至不适用。它是工作的正确工具。

@Potatoswatter：谢谢，我今天学习了一种新的 STL 算法！

太好了，谢谢十亿，partial_sort_copy 的顺序是什么？

【参考方案2】：

#include <iostream>
#include <map>
#include <vector>
#include <algorithm>
#include <string>
using namespace std;

int main(int argc, const char * argv[])

    map<string, int> entries;

    // insert some random entries
    for(int i = 0; i < 100; ++i)
    
        string name(5, 'A' + (char)(rand() % (int)('Z' - 'A') ));
        int number = rand() % 100;

        entries.insert(pair<string, int>(name, number));
    

    // create container for top 10
    vector<pair<string, int>> sorted(10);

    // sort and copy with reversed compare function using second value of std::pair
    partial_sort_copy(entries.begin(), entries.end(),
                      sorted.begin(), sorted.end(),
                      [](const pair<string, int> &a, const pair<string, int> &b)
    
        return !(a.second < b.second);
    );

    cout << endl << "all elements" << endl;

    for(pair<string, int> p : entries)
    
        cout << p.first << "  " << p.second << endl;
    

    cout << endl << "top 10" << endl;

    for(pair<string, int> p : sorted)
    
        cout << p.first << "  " << p.second << endl;
    

    return 0;

【参考方案3】：

std::map 不仅不按映射到的值排序（这样的值不需要有任何定义的排序顺序），它不允许重新排列其元素，因此在映射值的假设结构上执行 ++ map[ "key1" ];返回键将使反向映射无效。

最好的办法是将键值对放入另一个结构中，并在需要反向映射时按值对其进行排序。如果您始终需要反向映射，则每次更改值时都必须删除、修改和重新添加。

将现有地图分类为新结构的最有效方法是 std::partial_sort_copy，正如（刚刚）由 Al Bundy 说明的那样。

【参考方案4】：

由于映射的值没有被索引，您必须阅读所有内容并选择 10 个最大值。

std::vector<mapped_type> v;
v.reserve(mymap.size());

for(const auto& Pair : mymap)
 v.push_back( Pair.second );

std::sort(v.begin(), v.end(), std::greater<mapped_type>());

for(std::size_t i = 0, n = std::min<int>(10,v.size()); i < n; ++i)
  std::cout << v[i] << ' ';

另一种方法是使用两个映射或一个双映射，因此映射的值将被排序。

【讨论】：

Hossein 想要钥匙，而不是价值吗？

【参考方案5】：

您正在寻找的算法是 nth_element，它对一个范围进行部分排序，以便第 n 个元素位于完全排序的范围内。例如，如果您希望前三项按降序排列，您可以编写（在伪 C++ 中）

nth_element(begin, begin + 3, end, predicate)

问题是 nth_element 不适用于 std::map。因此，我建议您将数据结构更改为成对的向量（并且根据您正在处理的数据量，您可能会发现这是一个更快的数据结构）。所以，在你的例子中，我会这样写：

typedef vector<pair<string, int>> MyVector;
typedef MyVector::value_type ValueType;

MyVector v; 

// You should use an initialization list here if your
// compiler supports it (mine doesn't...)
v.emplace_back(ValueType("key1", 10));
v.emplace_back(ValueType("key2", 3));
v.emplace_back(ValueType("key3", 230));
v.emplace_back(ValueType("key4", 15));
v.emplace_back(ValueType("key5", 1));
v.emplace_back(ValueType("key6", 66));
v.emplace_back(ValueType("key7", 10));

nth_element(v.begin(), v.begin() + 3, v.end(), 
    [](ValueType const& x, ValueType const& y) -> bool
    
        // sort descending by value
        return y.second < x.second;
    );

// print out the top three elements
for (size_t i = 0; i < 3; ++i)
    cout << v[i].first << ": " << v[i].second << endl;

【参考方案6】：

#include "stdafx.h"
#include <iostream>
#include <vector>
#include <map>
#include <string>
#include <algorithm>
#include <cassert>
#include <iterator>
using namespace std;

class MyMap

public:
    MyMap();
    void addValue(string key, int value)
    
        _map[key] = value;
        _vec.push_back(make_pair(key, value));
        sort(_vec.begin(), _vec.end(), Cmp());
    
    vector<pair<string, int> > getTop(int n)
    
        int len = min((unsigned int)n, _vec.size());
        vector<Pair> res;
        copy(_vec.begin(), _vec.begin() + len, back_inserter(res));
        return res;
    
private:
    typedef map<string, int> StrIntMap;
    typedef vector<pair<string, int> > PairVector;
    typedef pair<string, int> Pair;
    StrIntMap  _map;
    PairVector _vec;
    struct Cmp: 
        public binary_function<const Pair&, const Pair&, bool>
    
        bool operator()(const Pair& left, const Pair& right)
        
            return right.second < left.second;
        
    ;
;

int main()

    MyMap mymap;
    mymap.addValue("key1", 10);
    mymap.addValue("key2", 3);
    mymap.addValue("key3", 230);
    mymap.addValue("key4", 15);
    mymap.addValue("key6", 66);
    mymap.addValue("key7", 10);

    auto res = mymap.getTop(3);

    for_each(res.begin(), res.end(), [](const pair<string, int> value)
                                        cout<<value.first<<" "<<value.second<<endl;);

【讨论】：

多映射不是更好的选择吗，因为与键不同的值可以重复并且无法在映射中表示？

【参考方案7】：

最简单的解决方案是使用std::transform 来构建 第二张地图：

typedef std::map<int, std::string> SortedByValue;
SortedByValue map2;
std::transform(
    mymap.begin(), mymap.end(),
    std::inserter( map2, map2.end() ),
    []( std::pair<std::string, int> const& original ) 
        return std::pair<int, std::string>( original.second, original.first );
         );

然后挑选map2 的最后n 个元素。

或者（并且可能更有效），您可以使用 std::vector<std::pair<int, std::string>> 并对其进行排序 之后：

std::vector<std::pair<int, std::string>> map2( mymap.size() );
std::transform(
    mymap.begin(), mymap.end()
    map2.begin(),
    []( std::pair<std::string, int> const& original ) 
        return std::pair<int, std::string>( original.second, original.first );
         );
std::sort( map2.begin(), map2.end() );

（请注意，这些解决方案会优化时间，但代价是 更多内存。）

【讨论】：

非常感谢:) 哪个算快？与手动遍历旧地图并将值插入新的多地图相比，std::transform() 有什么好处吗？（因为肯定有相同的出现，我不想丢失它们）？与使用地图相比，在向量中的每次插入中创建/删除/复制项目效率低吗？

带有向量的解决方案肯定是这里考虑的两个解决方案中更快的（尽管带有partial_sort_copy 的解决方案可能更快）。插入地图（或多地图）通常是一项相当昂贵的操作；插入向量非常快（平均而言），并且在第二个解决方案中，最初以所需的大小构造向量。 （一个有趣的替代方法是使用目标大小的向量，使用第一个 n 元素初始化，然后作为堆管理，在其余元素上使用 for_each。