如何在不使用 lambda 表达式的情况下实现特定的比较器？答案

【问题标题】：How to implement a specific comparator without using the lambda expression?如何在不使用 lambda 表达式的情况下实现特定的比较器？
【发布时间】：2017-01-21 03:32:51
【问题描述】：

我从here 获得以下代码。

class Solution {
public:
  vector<pair<int, int>> kSmallestPairs(vector<int>& nums1, vector<int>& nums2, int k) {
    vector<pair<int,int>> result;
    if (nums1.empty() || nums2.empty() || k <= 0)
        return result;
    auto comp = [&nums1, &nums2](pair<int, int> a, pair<int, int> b) {
        return nums1[a.first] + nums2[a.second] > nums1[b.first] + nums2[b.second];};
    priority_queue<pair<int, int>, vector<pair<int, int>>, decltype(comp)> min_heap(comp);
    min_heap.emplace(0, 0);
    while(k-- > 0 && min_heap.size())
    {
        auto idx_pair = min_heap.top(); min_heap.pop();
        result.emplace_back(nums1[idx_pair.first], nums2[idx_pair.second]);
        if (idx_pair.first + 1 < nums1.size())
            min_heap.emplace(idx_pair.first + 1, idx_pair.second);
        if (idx_pair.first == 0 && idx_pair.second + 1 < nums2.size())
            min_heap.emplace(idx_pair.first, idx_pair.second + 1);
    }
    return result;
  }
};

只有一行 lambda 表达式来实现比较器：

auto comp = [&nums1, &nums2](pair<int, int> a, pair<int, int> b) {
        return nums1[a.first] + nums2[a.second] > nums1[b.first] + nums2[b.second];};

pair.first 索引第一个数组nums1，而pair.second 索引第二个数组nums2。

此比较器比较两对，其中每对包含两个数组（向量）的索引。如果第一对 (array1[first_pair.first]+array2[first_pair.second]) 的对应数组总和大于第二对，则表达式返回 true。

我的问题是，我们可以使用结构来实现相同的比较器吗？困难的部分是我们如何将两个数组作为参数传递给比较器。

比较两对（不是两个数组的索引）的结构可以这样实现：

struct myCompare {
  bool operator() (const pair<int,int> lhs, const pair<int,int> rhs) const
  { return (lhs.first+lhs.second < rhs.first+rhs.second); }
};

但这是比较对条目的总和。现在我们要比较由对索引的两个数组条目的总和。

【问题讨论】：

标签： c++ lambda parameter-passing overriding

【解决方案1】：

您可以在比较器的构造函数中传递数组。

struct myCompare {

  // pass capture variables using constructor
  myCompare(const std::vector<int>& nums1, std::vector<int>& nums2)
  : nums1(nums1), nums2(nums2) {}

  bool operator() (const pair<int,int> lhs, const pair<int,int> rhs) const
  { return (nums1[lhs.first] + nums2[lhs.second] < nums1[rhs.first] + nums2[rhs.second]); }

private:
  const std::vector<int>& nums1;
  const std::vector<int>& nums2;
};

然后像这样使用它：

myCompare comp(nums1, nums2);

priority_queue<pair<int, int>, vector<pair<int, int>>, myCompare> min_heap(comp);

【讨论】：

这个解决方案很好。它启发了我，我们还可以使用两个指向array.begin() 的迭代器作为比较器的成员变量。并且该条目可以通过begin_iterator+index访问。

【解决方案2】：

将比较器与构造函数一起使用。见下文。注意，我们通过 const 引用传递构造函数和操作符参数。

struct MyCompare
{
    MyCompare(const vector<int>& arOne, const vector<int>& arTwo)
        : nums1(arOne), nums2(arTwo)
    {}

    bool operator() (const pair<int,int>& lhs, const pair<int,int>& rhs) const
    {
        return nums1[lhs.first] + nums2[lhs.second] 
               > nums1[rhs.first] + nums2[rhs.second];
    }

    const vector<int>& nums1;
    const vector<int>& nums2;
};

//定义如下

std::priority_queue<pair<int, int>, vector<pair<int, int> >, MyCompare> 
min_heap(MyCompare(arOne, arTwo));

【讨论】：