Algorithmes STL en C++

1. Utilisez l’algorithme std::sort pour trier les plages de vecteurs génériques en C++
2. Utilisez l’algorithme std::reverse pour inverser l’ordre des éléments en C++
3. Utilisez l’algorithme std::accumulate pour calculer la somme des éléments d’une plage en C++
4. Utilisez l’algorithme std::count pour compter le nombre d’éléments satisfaisant aux critères spécifiques en C++

Cet article présentera plusieurs fonctions de la bibliothèque d’algorithmes STL en C++.

Utilisez l’algorithme std::sort pour trier les plages de vecteurs génériques en C++

std::sort est l’un des algorithmes les plus utilisés en STL. Il a plusieurs surcharges, dont la plus simple accepte deux itérateurs qui répondent aux exigences LegacyRandomAccessIterator et trie les éléments dans un ordre non décroissant. Ce dernier est dit parce que l’ordre des éléments égaux n’est pas garanti d’être préservé.

std::sort est couramment utilisé sur les plages vector. L’extrait de code suivant illustre l’utilisation en tant que telle. L’algorithme peut éventuellement prendre la fonction de comparaison, qui sera utilisée pour évaluer les paires d’éléments et trier la plage en conséquence.

L’exemple suivant montre une ligne où l’objet de fonction STL - std::greater est passé en tant que fonction de comparaison. Alternativement, on peut définir un objet de fonction personnalisé ou spécifier l’expression lambda directement comme troisième paramètre de std::sort.

#include <algorithm>
#include <iostream>
#include <string>
#include <vector>

using std::cin;
using std::cout;
using std::endl;
using std::string;
using std::vector;

template <typename T>
void printRange(std::vector<T> v) {
  for (const auto &item : v) {
    cout << item << ", ";
  }
  cout << endl;
}

int main() {
  std::vector<int> v1 = {1, 3, 5, 11, 9, 10, 13, 20};

  std::sort(v1.begin(), v1.end());
  printRange(v1);

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

  std::sort(v1.begin(), v1.end(), [](int a, int b) { return (a - 2) != b; });
  printRange(v1);

  return EXIT_SUCCESS;
}

Production:

1, 3, 5, 9, 10, 11, 13, 20,
20, 13, 11, 10, 9, 5, 3, 1,
1, 3, 5, 9, 10, 11, 13, 20

Utilisez l’algorithme std::reverse pour inverser l’ordre des éléments en C++

std::reverse peut être utilisé pour inverser le contenu des conteneurs de séquences tels que vector, list ou deque. La fonction accepte deux paramètres d’itérateur et peut opérer sur n’importe quel type générique. L’exemple de code suivant montre deux scénarios dans lesquels le vector d’entiers et list de chaînes sont inversés. Nous trions également l’objet list en utilisant la fonction membre sort avant d’appeler l’algorithme std::reverse. Notez que l’algorithme std::sort ne fonctionne pas sur le conteneur std::list.

#include <algorithm>
#include <iostream>
#include <list>
#include <string>
#include <vector>

using std::cin;
using std::cout;
using std::endl;
using std::list;
using std::string;
using std::vector;

template <typename T>
void printRange(std::vector<T> v) {
  for (const auto &item : v) {
    cout << item << ", ";
  }
  cout << endl;
}

template <typename T>
void printRange(std::list<T> v) {
  for (const auto &item : v) {
    cout << item << ", ";
  }
  cout << endl;
}

int main() {
  std::vector<int> v1 = {1, 3, 5, 11, 9, 10, 13, 20};
  std::list<string> l1 = {"htop", "wtop", "rtop", "ktop", "ktop", "ptop"};

  std::reverse(v1.begin(), v1.end());
  printRange(v1);

  l1.sort();
  std::reverse(l1.begin(), l1.end());
  printRange(l1);

  return EXIT_SUCCESS;
}

Production:

20, 13, 10, 9, 11, 5, 3, 1,
wtop, rtop, ptop, ktop, ktop, htop,

Utilisez l’algorithme std::accumulate pour calculer la somme des éléments d’une plage en C++

std::accumulate fait partie des algorithmes numériques qui peuvent être utilisés pour effectuer des opérations arithmétiques communes sur chaque élément de la plage donnée. Dans ce cas, l’algorithme donné calcule la somme totale de chaque élément de la plage. std::accumulate a deux surcharges, dont la première prend les deux itérateurs indiquant la plage elle-même et la valeur init, qui représente la valeur de départ pour la sommation. La deuxième surcharge peut éventuellement prendre un objet fonction comme quatrième paramètre appliqué au lieu de la sommation.

#include <algorithm>
#include <iostream>
#include <numeric>
#include <string>
#include <vector>

using std::cin;
using std::cout;
using std::endl;
using std::string;
using std::vector;

int main() {
  std::vector<int> v1 = {1, 3, 5, 11, 9, 10, 13, 20};

  auto sum = std::accumulate(v1.begin(), v1.end(), 0);
  cout << "Sum of 'v1' vector = " << sum << endl;

  sum = std::accumulate(v1.begin(), v1.end(), 1, std::multiplies());
  cout << "Accumulate of 'v1' vector = " << sum << endl;

  return EXIT_SUCCESS;
}

Production:

Sum of 'v1' vector = 72
Accumulate of 'v1' vector = 3861000

Utilisez l’algorithme std::count pour compter le nombre d’éléments satisfaisant aux critères spécifiques en C++

La fonction std::count est une méthode utile pour compter des éléments spécifiques dans la plage donnée. À savoir, nous pouvons passer les itérateurs de plage et la value pour faire correspondre tous les éléments qui sont égaux à la valeur donnée. Une autre surcharge peut accepter un prédicat unaire qui renvoie évaluer les correspondances valides, et l’algorithme récupère le nombre de comptage en conséquence. Dans l’exemple suivant, nous avons spécifié une expression lambda pour compter les nombres pairs dans l’objet vector.

#include <algorithm>
#include <iostream>
#include <list>
#include <numeric>
#include <string>
#include <vector>

using std::cin;
using std::cout;
using std::endl;
using std::string;
using std::vector;

int main() {
  std::vector<int> v1 = {1, 3, 5, 11, 9, 10, 13, 20};

  auto count_10 = std::count(v1.begin(), v1.end(), 10);
  cout << count_10 << " occurrences of number 10" << endl;

  auto count_even =
      std::count_if(v1.begin(), v1.end(), [](int i) { return i % 2 == 0; });
  cout << count_even << " even numbers in 'v1' vector" << endl;

  return EXIT_SUCCESS;
}

Production:

1 occurrences of number 10
2 even numbers in 'v1' vector