定义 < 比较器时按降序对对象进行排序？

Question

我有一个类A 和一个< 比较器。如何使用它们以降序顺序对A 数组进行排序？

class A {
...
};

class LessA {
   bool operator()(const A& a1, const A& a2) const {
   ...
   }
}

vector<A> v;
sort(v.begin(), v.end(), ???);

我想我应该用基于LessA 的东西替换???，但我不知道应该放什么。我想使用 lambda 函数，但我正在寻找更短的东西。

Answer 1

如果您想根据 LessA 比较器定义的关系进行排序，只需将 LessA 的实例作为第三个参数传递（并且，由于您使用的是 C++11，因此更喜欢全局 std::begin()和std::end()函数）：

std::sort(std::begin(a), std::end(a), LessA());
//                                    ^^^^^^^

现在，如果您的LessA() 表达了< 关系并且您想根据相反的标准进行排序，您可以这样做：

std::sort(std::begin(a), std::end(a), 
    [] (A const& a1, A const& a2))
{
    return LessA()(a2, a1);
}

您可以做的另一件事是让您的自定义比较器接受一个参数来确定它应该如何执行比较：

class CompA {
    bool lessThan;
public:
    CompA(bool lessThan) : _lessThan(lessThan) { }
    bool operator()(const A& a1, const A& a2) const {
        if (_lessThan)
        {
            // return true iff a1 < a2;
        }
        else
        {
            // return true iff a1 > a2;
        }
    }
};

然后您可以使用这种方式按升序排序：

std::sort(std::begin(a), std::end(a), CompA(true));

而这种方式按降序排序：

std::sort(std::begin(a), std::end(a), CompA(false));

鉴于您原来的 LessA 比较器，另一种可能性是使用 std::bind 将参数的顺序交换到您的自定义比较器：

LessA comp;
using namespace std::placeholders;
std::sort(std::begin(v), std::end(v), 
    std::bind(&LessA::operator(), comp, _2, _1));

Answer 2

使LessA 类的() 运算符返回!(a1 < a2) 并像这样传入：

std::sort(v.begin(), v.end(), LessA());

Answer 3

将范围向后排序：

vector<A> v;
sort(v.rbegin(), v.rend(), LessA());

rbegin 和 rend 为您提供反向迭代器。

如果太混乱，请封装：

void reverse_sort(vector<A>& v) {
    sort(v.rbegin(), v.rend(), LessA());    
}

用法：

vector<A> v;
reverse_sort(v);

Answer 4

使用std::greater 作为比较函子。默认（std::less）会给你一个升序；这会给你一个降序。 （您需要添加 using namespace std::rel_ops; (link) 语句或明确定义 operator>。）

示例

取自cppreference.com

#include <algorithm>
#include <functional>
#include <array>
#include <iostream>
 
int main()
{
    std::array<int, 10> s = {5, 7, 4, 2, 8, 6, 1, 9, 0, 3}; 
 
    // sort using the default operator<
    std::sort(s.begin(), s.end());
    for (int a : s) {
        std::cout << a << " ";
    }   
    std::cout << '\n';
 
    // sort using a standard library compare function
    std::sort(s.begin(), s.end(), std::greater<int>());
    for (int a : s) {
        std::cout << a << " ";
    }   
    std::cout << '\n';
 
    // sort using a custom functor
    struct {
        bool operator()(int a, int b)
        {   
            return a < b;
        }   
    } customLess;
    std::sort(s.begin(), s.end(), customLess);
    for (int a : s) {
        std::cout << a << " ";
    }   
    std::cout << '\n';
 
    // sort using a lambda
    std::sort(s.begin(), s.end(), [](int a, int b) {
        return b < a;   
    });
    for (int a : s) {
        std::cout << a << " ";
    } 
    std::cout << '\n';
}

Answer 5

给定一个实现a<b 的函数lt(a, b)，您可以通过返回!lt(a, b) 创建一个实现a>=b 的函数。要实现>，需要返回!lt(b, a) && !(lt(a,b) || lt(b,a))。

lt(a, b) || lt(b, a) 等价于a!=b，所以上面等价于a>=b && a!=b 减少为a>b。

但是，您可能只需要std::not2(LessA()) 就可以逃脱惩罚。这将使用>= 进行排序，并按降序排序。