Kullanmalı mıyım

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

veya

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

vektörü azalan düzende sıralamak için? Bir yaklaşımla ya da diğeriyle herhangi bir fayda ya da dezavantaj var mı?

Aslında ilki kötü bir fikir. İkincisini veya şunu kullanın :

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

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

Bu şekilde, birisinin numberstutması gerektiğine longveya long longyerine karar verdiğinizde kodunuz sessizce kırılmaz int.

İlkini kullanın:

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

Misreading az şans - O ne olup bittiğini açık olduğunu rbeginolarak beginhatta bir yorum ile. Net ve okunabilir olan tam olarak ne istediğinizi.

Ayrıca, ikincisi, ters yineleyicilerin doğası göz önüne alındığında ilkinden daha az verimli olabilir, ancak emin olmak için profilinizi oluşturmanız gerekir.

C ++ 14 ile bunu yapabilirsiniz:

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

Peki buna ne dersin?

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

Mehrdad'ın önerdiği gibi bir işlev yerine bir Lambda işlevi kullanabilirsiniz.

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

long longMakineme göre, ilk yöntemi kullanarak [1..3000000] vektörünün sıralanması yaklaşık 4 saniye sürerken, ikinci yöntemi kullanmak yaklaşık iki kez sürmektedir. Açıkçası bir şey söylüyor, ama nedenini de anlamıyorum. Bunun yararlı olacağını düşünün.

Aynı şey burada da bildirildi .

Xeo tarafından söylendiği gibi, -O3bitirmek için yaklaşık aynı zamanı kullanıyorlar.

İlk yaklaşım şunları ifade eder:

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

İkinciden daha fazla verim alması nedeniyle ilk yaklaşımı kullanabilirsiniz.
İlk yaklaşımın zaman karmaşıklığı ikincisinden daha az.

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

TL; DR

Herhangi birini kullanın. Neredeyse aynılar.

Sıkıcı cevap

Her zamanki gibi, artıları ve eksileri vardır.

Kullanım std::reverse_iterator:

• Özel türleri sıralarken ve uygulamak istemediğinizde operator>()
• Yazmak için çok tembel olduğunuzda std::greater<int>()

Aşağıdaki std::greaterdurumlarda kullanın :

• Daha açık bir kod olmasını istediğinizde
• Belirsiz ters yineleyiciler kullanmaktan kaçınmak istediğinizde

Performansa gelince, her iki yöntem de eşit derecede verimlidir. Aşağıdaki ölçütleri denedim:

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

Bu komut satırı ile:

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

Zamanlamalar aynı. Valgrind aynı sayıda önbellek kaybını rapor eder.

Her ikisinin de kafa karıştırıcı olduğu ve ikincisinin Mehrdad'ın önerdiği gibi kırılgan olduğu için sorudaki yöntemlerden birini kullanmanız gerektiğini düşünmüyorum.

Standart bir kütüphane işlevi gibi göründüğü ve amacını açıkladığı için aşağıdakileri savunurum:

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

İlkini kullanabilir veya eşit derecede verimli olan aşağıdaki kodu deneyebilirsiniz

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