사용해야합니까

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

또는

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

내림차순으로 벡터를 정렬하려면? 하나의 접근 방식이나 다른 접근 방식의 이점이나 단점이 있습니까?

사실, 첫 번째는 나쁜 생각입니다. 두 번째 또는이 중 하나를 사용하십시오 .

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

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

그렇게하면 누군가가 또는 대신 대신 numbers해야한다고 결정할 때 코드가 자동으로 중단되지 않습니다 .longlong longint

첫 번째를 사용하십시오.

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

오독의 적은 기회 - 그것은에 무슨 일이 일어나고 있는지의 명시 적이다 rbegin등 begin도 코멘트와 함께. 명확하고 읽을 수 있으며 정확히 원하는 것입니다.

또한 두 번째는 리버스 반복자의 특성으로 인해 첫 번째보다 효율이 떨어질 수 있지만 확실하게 프로파일 링해야합니다.

c ++ 14를 사용하면 다음을 수행 할 수 있습니다.

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

이건 어때?

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

Mehrdad가 제안한 functor 대신 Lambda 함수를 사용할 수 있습니다.

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

내 컴퓨터에 따르면 long long첫 번째 방법을 사용하여 [1..3000000] 의 벡터를 정렬하는 데는 약 4 초가 걸리고 두 번째 방법을 사용하면 약 두 배가 걸립니다. 그것은 분명히 무언가를 말하지만, 나는 왜 그런지 이해하지 못합니다. 이것이 도움이 될 것이라고 생각하십시오.

여기에 동일한 내용이보고 되었습니다 .

Xeo가 말했듯이, -O3그들은 거의 같은 시간을 사용하여 마무리합니다.

첫 번째 접근 방식은 다음과 같습니다.

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

두 번째보다 효율성이 높아 첫 번째 방법을 사용할 수 있습니다.
첫 번째 방법의 시간 복잡도는 두 번째 방법보다 적습니다.

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

TL; DR

아무거나 사용하십시오. 그들은 거의 같습니다.

지루한 답변

평소와 같이 장단점이 있습니다.

사용 std::reverse_iterator:

• 사용자 정의 유형을 정렬하고 구현하지 않으려는 경우 operator>()
• 입력하기에 너무 게으른 경우 std::greater<int>()

다음과 같은 std::greater경우에 사용하십시오 .

• 보다 명확한 코드를 원할 때
• 모호한 역 반복자를 사용하지 않으려는 경우

성능면에서 두 방법 모두 동일하게 효율적입니다. 다음 벤치 마크를 시도했습니다.

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

이 명령 행으로 :

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

타이밍은 동일합니다. Valgrind는 같은 수의 캐시 누락을보고합니다.

나는 두 가지 방법이 혼란 스럽기 때문에 질문에 방법 중 하나를 사용해야한다고 생각하지 않으며 두 번째 방법은 Mehrdad가 제안한 것처럼 깨지기 쉽습니다.

나는 표준 라이브러리 함수처럼 보이고 의도를 명확하게하기 때문에 다음을 옹호합니다.

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

첫 번째 코드를 사용하거나 아래 코드를 사용해보십시오.

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