Haruskah saya gunakan

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

atau

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

untuk mengurutkan vektor dalam urutan menurun? Apakah ada manfaat atau kelemahan dengan satu pendekatan atau yang lain?

Sebenarnya, yang pertama adalah ide yang buruk. Gunakan yang kedua , atau ini:

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

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

Dengan cara itu kode Anda tidak akan diam-diam rusak ketika seseorang memutuskan numbersharus menahan longatau long longbukannya int.

Gunakan yang pertama:

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

Ini eksplisit apa yang terjadi - lebih sedikit kesempatan untuk salah membaca rbeginsebagai begin, bahkan dengan komentar. Ini jelas dan mudah dibaca yang persis apa yang Anda inginkan.

Juga, yang kedua mungkin kurang efisien daripada yang pertama mengingat sifat iterator terbalik, meskipun Anda harus membuat profil untuk memastikannya.

Dengan c ++ 14 Anda dapat melakukan ini:

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

Bagaimana dengan ini?

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

Alih-alih functor seperti yang diusulkan Mehrdad, Anda bisa menggunakan fungsi Lambda.

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

Menurut mesin saya, mengurutkan long longvektor [1..3000000] menggunakan metode pertama membutuhkan waktu sekitar 4 detik, sedangkan menggunakan yang kedua membutuhkan waktu sekitar dua kali lipat. Itu mengatakan sesuatu, tentu saja, tetapi saya juga tidak mengerti mengapa. Hanya berpikir ini akan sangat membantu.

Hal yang sama dilaporkan di sini .

Seperti yang dikatakan oleh Xeo, dengan -O3mereka menggunakan waktu yang hampir bersamaan untuk menyelesaikannya.

Pendekatan pertama mengacu:

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

Anda dapat menggunakan pendekatan pertama karena mendapatkan lebih banyak efisiensi daripada yang kedua.
Kompleksitas waktu pendekatan pertama kurang dari yang kedua.

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

TL; DR

Gunakan apa saja. Mereka hampir sama.

Jawaban yang membosankan

Seperti biasa, ada pro dan kontra.

Gunakan std::reverse_iterator:

• Saat Anda menyortir jenis khusus dan Anda tidak ingin menerapkan operator>()
• Saat Anda terlalu malas mengetik std::greater<int>()

Gunakan std::greatersaat:

• Ketika Anda ingin memiliki kode yang lebih eksplisit
• Saat Anda ingin menghindari penggunaan iterator terbalik yang tidak jelas

Adapun kinerja, kedua metode sama-sama efisien. Saya mencoba patokan berikut:

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

Dengan baris perintah ini:

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

Pengaturan waktunya sama. Valgrind melaporkan jumlah cache yang sama.

Saya tidak berpikir Anda harus menggunakan salah satu metode dalam pertanyaan karena keduanya membingungkan, dan yang kedua rapuh seperti yang disarankan Mehrdad.

Saya akan menganjurkan berikut ini, karena terlihat seperti fungsi perpustakaan standar dan memperjelas niatnya:

#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>());
}

Anda dapat menggunakan yang pertama atau mencoba kode di bawah ini yang sama-sama efisien

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