Question

我有一张地图，我想在地图中找到最小值（右侧）。现在我就是这样做的

bool compare(std::pair<std::string ,int> i, pair<std::string, int> j) {
  return i.second < j.second;
}
////////////////////////////////////////////////////
std::map<std::string, int> mymap;

mymap["key1"] = 50;
mymap["key2"] = 20;
mymap["key3"] = 100;

std::pair<char, int> min = *min_element(mymap.begin(), mymap.end(), compare); 
std::cout << "min " << min.second<< " " << std::endl;

这很好用，当我把这个代码放在我的课程中它似乎不起作用时，我能够得到问题的最小值

int MyClass::getMin(std::map<std::string, int> mymap) {
  std::pair<std::string, int> min = *min_element(mymap.begin(), mymap.end(), 
                                                 (*this).compare);
                                                 //error probably due to this

  return min.second; 
}

bool MyClass::compare(
    std::pair<std::string, int> i, std::pair<std::string, int> j) { 
  return i.second < j.second; 
}

还有一个更好的解决方案，不涉及编写额外的compare函数

Answer 1

您有几个选择。 “最佳”方法是使用仿函数，这是最快的调用方式：

typedef std::pair<std::string, int> MyPairType;
struct CompareSecond
{
    bool operator()(const MyPairType& left, const MyPairType& right) const
    {
        return left.second < right.second;
    }
};



int MyClass::getMin(std::map<std::string, int> mymap) 
{
  std::pair<std::string, int> min 
      = *min_element(mymap.begin(), mymap.end(), CompareSecond());
  return min.second; 
}

（您也可以将CompareSecond类嵌套在MyClass内。

使用您现在拥有的代码，您可以轻松地将其修改为可行。只需创建函数static并使用正确的语法：

static bool 
MyClass::compare(std::pair<std::string, int> i, std::pair<std::string, int> j) 
{ 
  return i.second < j.second; 
}

int MyClass::getMin(std::map<std::string, int> mymap) 
{
  std::pair<std::string, int> min = *min_element(mymap.begin(), mymap.end(), 
                                                 &MyClass::compare);
  return min.second; 
}

Answer 2

在C ++ 11中，你可以这样做：

auto it = min_element(pairs.begin(), pairs.end(),
                      [](decltype(pairs)::value_type& l, decltype(pairs)::value_type& r) -> bool { return l.second < r.second; });

或者把它放在这样一个很好的函数中（注意我不是模板大师;这在许多方面可能是错误的）：

template <typename T>
typename T::iterator min_map_element(T& m)
{
    return min_element(m.begin(), m.end(), [](typename T::value_type& l, typename T::value_type& r) -> bool { return l.second < r.second; });
}

Answer 3

问题在于：

bool MyClass::compare

需要调用类的实例。也就是说，您不能只拨打MyClass::compare，但需要someInstance.compare。但是，min_element需要前者。

简单的解决方案是将其static：

static bool MyClass::compare

// ...

min_element(mymap.begin(), mymap.end(), &MyClass::compare);

这不再需要调用实例，您的代码也没问题。但是，您可以使用仿函数使其更通用：

struct compare2nd
{
    template <typename T>
    bool operator()(const T& pLhs, const T& pRhs)
    {
        return pLhs.second < pRhs.second;
    }
};

min_element(mymap.begin(), mymap.end(), compare2nd());

所有这一切都是抓住每对中的第二个并抓住它们，适用于任何一对。它可以用于一般情况，但这有点太多了。

如果您需要按足够的价值查找，我建议您使用Boost的Bimap。它是一个双向映射，因此键和值都可用于查找。您只需获取值键映射的前面。

最后，您始终可以跟踪进入地图的最小元素。每次插入一个新值时，检查它是否低于当前值（并且它应该是指向映射对的指针，将其作为空值启动），如果它更低，则指向新的最低值。请求最低值就像取消引用指针一样简单。

Answer 4

我实际上有另一个问题：如果你需要定期获得最小的右侧值，你确定map是最好的结构吗？

我建议一般使用Boost.MultiIndex来解决同一组对象索引的多种方法的问题......但是如果你只需要这个“反向映射”位Boost.Bimap可能会更容易

这样，在寻找最小值时，您将无法进行线性搜索。

Answer 5

C ++ 14

如Jonathan Geisler's对Timmmm's answer的评论中所述，C++14允许lambda function参数用auto类型说明符声明。因此，您可以按以下方式缩短Timmmm基于lambda的min_element行（并提高其可读性）：

auto it = std::min_element(std::begin(mymap), std::end(mymap),
                           [](const auto& l, const auto& r) { return l.second < r.second; });

注1：如果将此行放入MyClass::getMin()函数中，则必须返回it->second。但是，要解决空地图的问题，您应该按如下方式（或类似方式）修改return行：

return it == mymap.end() ? -1 : it->second;

注2：如Lance Diduck所述，您应该通过const引用传递对getMin()函数的映射。这样做的方式是创建整个地图的不必要副本。

Code on Ideone

在Map中查找最小值

5 个答案:

C ++ 14