c++ - mostrar - ordenar numeros de forma ascendente y descendente

Ordenar un vector en orden descendente

Question

Debo usar

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

o

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

ordenar un vector en orden descendente? ¿Hay algún beneficio o inconveniente con un enfoque u otro?

Answer 1

El primer enfoque se refiere:

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

Puede utilizar el primer enfoque porque obtiene más eficiencia que el segundo.
La complejidad del tiempo del primer acercamiento es menor que la del segundo.

Answer 2

Con c ++ 14 puedes hacer esto:

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

Answer 3

De acuerdo con mi máquina, la clasificación de un vector long long de [1..3000000] usando el primer método toma alrededor de 4 segundos, mientras que usar la segunda toma aproximadamente el doble del tiempo. Eso dice algo, obviamente, pero tampoco entiendo por qué. Solo piensa que esto sería útil.

Lo mismo se informó here .

Como dijo Xeo, con -O3 se usa casi al mismo tiempo para terminar.

Answer 4

El enfoque más corto es:

std::sort(v.rbegin(), v.rend());

Answer 5

En lugar de un funtor como Mehrdad propuso, podrías usar una función Lambda.

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

Answer 6

En realidad, la primera es una mala idea. Usa el segundo o este:

struct greater
{
template<class T>
bool operator()(T const &a, T const &b) const { return a > b; }
};
std::sort(numbers.begin(), numbers.end(), greater());

De esa manera, su código no se romperá silenciosamente cuando alguien decida que los numbers deben mantenerse long o long long lugar de int .

Answer 7

No creo que debas usar ninguno de los métodos de la pregunta, ya que ambos son confusos, y el segundo es frágil como sugiere Mehrdad.

Abogaría por lo siguiente, ya que parece una función de biblioteca estándar y deja clara su intención:

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

Answer 8

Puede usar el primero o probar el siguiente código, que es igualmente eficiente:

sort(a,a+n+1,greater<int>());

Answer 9

Que hay de esto

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

Answer 10

Usa el primero:

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

Es explícito de lo que está pasando, menos posibilidades de leer mal a rbegin como begin , incluso con un comentario. Es claro y legible, que es exactamente lo que quieres.

Además, el segundo puede ser menos eficiente que el primero dada la naturaleza de los iteradores inversos, aunque tendría que perfilarlo para estar seguro.

Answer 11

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