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

Question

I have a class A and a < comparator. How can I use them to sort an array of A in descending order?

class A {
...
};

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

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

I suppose I should replace the ??? with something based on LessA , but I can't figure out what should go in there. I thought of using a lambda function, but I was looking for something shorter.

Answer 1

If you want to sort according to the relation defined by your LessA comparator, just pass an instance of LessA as the third argument (and, since you are using C++11, prefer the global std::begin() and std::end() functions):

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

Now if your LessA() expresses the < relation and you want to sort according to the opposite criterion, you could do:

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

Another thing you could do is to let your custom comparator accept an argument that determines how it should perform the comparison:

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;
        }
    }
};

You could then use it this way to sort in ascending order:

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

And this way to sort in descending order:

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

Another possibility, given your original LessA comparator, is to use std::bind to swap the order of the arguments to your custom comparator:

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

Answer 2

Sort the range backwards:

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

rbegin , and rend give you reverse iterators.

Encapsulate if it's too confusing:

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

Usage:

vector<A> v;
reverse_sort(v);

Answer 3

Use std::greater for the comparison functor. The default ( std::less ) will give you an ascending order; this will give you a descending order. (You'll need to add a using namespace std::rel_ops; ( link ) statement or explicitly define operator> as well.)

Example

Taken from 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 4

Given a function lt(a, b) that implements a<b , you can create a function that implements a>=b by returning !lt(a, b) . To implement > , you need to return !lt(b, a) && !(lt(a,b) || lt(b,a)) .

lt(a, b) || lt(b, a) lt(a, b) || lt(b, a) is equivalent to a!=b , so the above is equivalent to a>=b && a!=b which reduces to a>b .

However, you can probably get away with just std::not2(LessA()) . That will sort with >= which will sort in descending order.

Answer 5

让LessA类的()运算符返回!(a1 < a2)并将其传递给：

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