Tôi có nên sử dụng

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

hoặc là

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

để sắp xếp một vectơ theo thứ tự giảm dần? Có bất kỳ lợi ích hoặc nhược điểm với cách tiếp cận này hay cách khác?

Thật ra, cái đầu tiên là một ý tưởng tồi. Sử dụng cái thứ hai hoặc cái này:

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

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

Bằng cách đó, mã của bạn sẽ không âm thầm phá vỡ khi ai đó quyết định numbersnên giữ longhoặc long longthay vì int.

Sử dụng đầu tiên:

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

Đó là rõ ràng về những gì đang xảy ra - ít cơ hội hiểu sai rbeginnhư begin, ngay cả với một nhận xét. Nó rõ ràng và dễ đọc, đó chính xác là những gì bạn muốn.

Ngoài ra, cái thứ hai có thể kém hiệu quả hơn cái thứ nhất có bản chất của các trình vòng lặp ngược, mặc dù bạn sẽ phải xác định nó để chắc chắn.

Với c ++ 14 bạn có thể làm điều này:

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

Cái này thì sao?

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

Thay vì functor như Mehrdad đề xuất, bạn có thể sử dụng hàm Lambda.

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

Theo máy của tôi, việc sắp xếp một long longvectơ [1..3000000] bằng phương pháp đầu tiên mất khoảng 4 giây, trong khi sử dụng lần thứ hai mất khoảng hai lần thời gian. Điều đó nói lên điều gì đó, rõ ràng, nhưng tôi cũng không hiểu tại sao. Chỉ cần nghĩ rằng điều này sẽ hữu ích.

Điều tương tự được báo cáo ở đây .

Như đã nói của Xeo, với việc -O3họ sử dụng cùng một lúc để hoàn thành.

Cách tiếp cận đầu tiên đề cập đến:

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

Bạn có thể sử dụng phương pháp đầu tiên vì đạt được hiệu quả cao hơn lần thứ hai.
Độ phức tạp thời gian của cách tiếp cận thứ nhất ít hơn lần thứ hai.

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

TL; DR

Sử dụng bất kỳ. Chúng gần như giống nhau.

Chán câu trả lời

Như thường lệ, có những ưu và nhược điểm.

Sử dụng std::reverse_iterator:

• Khi bạn sắp xếp các loại tùy chỉnh và bạn không muốn thực hiện operator>()
• Khi bạn quá lười để gõ std::greater<int>()

Sử dụng std::greaterkhi:

• Khi bạn muốn có nhiều mã rõ ràng hơn
• Khi bạn muốn tránh sử dụng các trình vòng lặp ngược tối nghĩa

Đối với hiệu suất, cả hai phương pháp đều hiệu quả như nhau. Tôi đã thử điểm chuẩn sau:

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

Với dòng lệnh này:

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

Thời gian là như nhau. Valgrind báo cáo cùng một số lỗi bộ nhớ cache.

Tôi không nghĩ bạn nên sử dụng một trong hai phương pháp trong câu hỏi vì cả hai đều khó hiểu và phương pháp thứ hai rất mong manh như Mehrdad gợi ý.

Tôi sẽ ủng hộ những điều sau đây, vì nó trông giống như một chức năng thư viện tiêu chuẩn và làm cho ý định của nó rõ ràng:

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

Bạn có thể sử dụng mã đầu tiên hoặc thử mã dưới đây có hiệu quả tương đương

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