ฉันควรใช้

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ควรถือlongหรือแทนlong longint

ใช้ครั้งแรก:

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

มันเป็นที่ชัดเจนของสิ่งที่เกิดขึ้น - มีโอกาสน้อยกว่าของ misreading 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 คุณสามารถใช้ฟังก์ชั่นแลมบ์ดา

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