Tri d’un vecteur par ordre décroissant

Devrais-je utiliser

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

ou

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

sortinger un vecteur en ordre décroissant? Y a-t-il des avantages ou des inconvénients d’une approche ou de l’autre?

En fait, la première est une mauvaise idée. Utilisez soit le deuxième , soit ceci:

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

De cette façon, votre code ne se brise pas en silence lorsque quelqu’un décide que les numbers doivent être long ou long long au lieu d’être int .

Utilisez le premier:

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

Il est explicite de ce qui se passe – moins de chance de mal interpréter rbegin au begin , même avec un commentaire. C’est clair et lisible, c’est exactement ce que vous voulez.

De plus, le second peut être moins efficace que le premier étant donné la nature des iterators inverses, même si vous devez le profiler pour être sûr.

Avec c ++ 14, vous pouvez le faire:

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

Et ça?

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

Au lieu d’un foncteur tel que proposé par Mehrdad, vous pouvez utiliser une fonction Lambda.

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

Selon ma machine, le sorting d’un long long vecteur long long de [1..3000000] en utilisant la première méthode prend environ 4 secondes, tandis que l’utilisation de la seconde prend environ deux fois plus de temps. Cela dit quelque chose, évidemment, mais je ne comprends pas pourquoi non plus. Pensez simplement que cela serait utile.

Même chose rapscope ici .

Comme dit par Xeo, avec -O3 ils utilisent à peu près le même temps pour finir.

L’approche la plus courte est la suivante:

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

La première approche fait référence à:

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

Vous pouvez utiliser la première approche en raison d’une efficacité supérieure à la seconde.
La complexité temporelle de la première approche est inférieure à la seconde.

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

Vous pouvez soit utiliser le premier, soit essayer le code ci-dessous, ce qui est tout aussi efficace:

 sort(a,a+n+1,greater()); 

Je ne pense pas que vous devriez utiliser l’une des méthodes de la question car elles sont toutes deux confuses, et la seconde est fragile, comme le suggère Mehrdad.

Je préconiserais ce qui suit, car il ressemble à une fonction de bibliothèque standard et rend son intention claire:

 #include  template  void reverse_sort(RandomIt first, RandomIt last) { std::sort(first, last, std::greater::value_type>()); }