Sollte ich es benutzen

std::sort(numbers.begin(), numbers.end(), std::greater<int>());

oder

std::sort(numbers.rbegin(), numbers.rend());   // note: reverse iterators

einen Vektor in absteigender Reihenfolge sortieren? Gibt es Vor- oder Nachteile bei dem einen oder anderen Ansatz?

Eigentlich ist der erste eine schlechte Idee. Verwenden Sie entweder den zweiten oder diesen:

struct greater
{
    template<class T>
    bool operator()(T const &a, T const &b) const { return a > b; }
};

std::sort(numbers.begin(), numbers.end(), greater());

Auf diese Weise wird Ihr Code nicht stillschweigend unterbrochen, wenn jemand entscheidet, numbersob er halten soll longoder long longnicht int.

Verwenden Sie die erste:

std::sort(numbers.begin(), numbers.end(), std::greater<int>());

Es ist explizit, was los ist - weniger Wahrscheinlichkeit, falsch zu lesen rbeginalsbegin auch mit einem Kommentar. Es ist klar und lesbar, was genau Sie wollen.

Aufgrund der Art der umgekehrten Iteratoren ist der zweite möglicherweise weniger effizient als der erste, obwohl Sie ihn zur Sicherheit profilieren müssten.

Mit c ++ 14 können Sie dies tun:

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

Was ist damit?

std::sort(numbers.begin(), numbers.end());
std::reverse(numbers.begin(), numbers.end());

Anstelle eines Funktors, wie Mehrdad vorgeschlagen hat, können Sie auch eine Lambda-Funktion verwenden.

sort(numbers.begin(), numbers.end(), [](const int a, const int b) {return a > b; });

Laut meiner Maschine long longdauert das Sortieren eines Vektors von [1..3000000] mit der ersten Methode ungefähr 4 Sekunden, während das Verwenden der zweiten Methode ungefähr doppelt so lange dauert. Das sagt natürlich etwas aus, aber ich verstehe auch nicht warum. Denken Sie nur, das wäre hilfreich.

Das Gleiche wurde hier berichtet .

Wie von Xeo gesagt, verwenden -O3sie ungefähr die gleiche Zeit, um fertig zu werden.

Der erste Ansatz bezieht sich auf:

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

Sie können den ersten Ansatz verwenden, weil Sie effizienter als der zweite sind.
Die Zeitkomplexität des ersten Ansatzes ist geringer als die des zweiten.

bool comp(int i, int j) { return i > j; }
sort(numbers.begin(), numbers.end(), comp);

TL; DR

Verwenden Sie eine. Sie sind fast gleich.

Langweilige Antwort

Wie immer gibt es Vor- und Nachteile.

Verwendung std::reverse_iterator:

• Wenn Sie benutzerdefinierte Typen sortieren und diese nicht implementieren möchten operator>()
• Wenn Sie zu faul zum Tippen sind std::greater<int>()

Verwenden Sie, std::greaterwenn:

• Wenn Sie expliziteren Code haben möchten
• Wenn Sie die Verwendung obskurer Reverse-Iteratoren vermeiden möchten

In Bezug auf die Leistung sind beide Methoden gleich effizient. Ich habe folgenden Benchmark ausprobiert:

#include <algorithm>
#include <chrono>
#include <iostream>
#include <fstream>
#include <vector>

using namespace std::chrono;

/* 64 Megabytes. */
#define VECTOR_SIZE (((1 << 20) * 64) / sizeof(int))
/* Number of elements to sort. */
#define SORT_SIZE 100000

int main(int argc, char **argv) {
    std::vector<int> vec;
    vec.resize(VECTOR_SIZE);

    /* We generate more data here, so the first SORT_SIZE elements are evicted
       from the cache. */
    std::ifstream urandom("/dev/urandom", std::ios::in | std::ifstream::binary);
    urandom.read((char*)vec.data(), vec.size() * sizeof(int));
    urandom.close();

    auto start = steady_clock::now();
#if USE_REVERSE_ITER
    auto it_rbegin = vec.rend() - SORT_SIZE;
    std::sort(it_rbegin, vec.rend());
#else
    auto it_end = vec.begin() + SORT_SIZE;
    std::sort(vec.begin(), it_end, std::greater<int>());
#endif
    auto stop = steady_clock::now();

    std::cout << "Sorting time: "
          << duration_cast<microseconds>(stop - start).count()
          << "us" << std::endl;
    return 0;
}

Mit dieser Befehlszeile:

g++ -g -DUSE_REVERSE_ITER=0 -std=c++11 -O3 main.cpp \
    && valgrind --cachegrind-out-file=cachegrind.out --tool=cachegrind ./a.out \
    && cg_annotate cachegrind.out
g++ -g -DUSE_REVERSE_ITER=1 -std=c++11 -O3 main.cpp \
    && valgrind --cachegrind-out-file=cachegrind.out --tool=cachegrind ./a.out \
    && cg_annotate cachegrind.out

std::greater demo std::reverse_iterator demo

Timings sind gleich. Valgrind meldet die gleiche Anzahl von Cache-Fehlern.

Ich denke nicht, dass Sie eine der Methoden in der Frage verwenden sollten, da beide verwirrend sind und die zweite fragil ist, wie Mehrdad vorschlägt.

Ich würde Folgendes befürworten, da es wie eine Standardbibliotheksfunktion aussieht und seine Absicht klar macht:

#include <iterator>

template <class RandomIt>
void reverse_sort(RandomIt first, RandomIt last)
{
    std::sort(first, last, 
        std::greater<typename std::iterator_traits<RandomIt>::value_type>());
}

Sie können entweder den ersten verwenden oder den folgenden Code ausprobieren, der gleichermaßen effizient ist

sort(&a[0], &a[n], greater<int>());