1. Algoirthmes de consultation (non-modifiants)

Ces fonctions permettent d'analyser ou de rechercher des données sans altérer le contenu du conteneur d'origine.

1.1 Recherche d'éléments : find et find_if

• find : localise la première occurence d'une valeur spécifique.
• find_if : identifie le premier élément répondant à une condition (prédicat).

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

std::vector<int> donnees = {10, 25, 40, 55, 70};

// Recherche d'une valeur exacte
auto it = std::find(donnees.begin(), donnees.end(), 40);
if (it != donnees.end()) {
    std::cout << "Trouvé : " << *it << std::endl;
}

// Recherche via une condition (premier multiple de 11)
auto it_cond = std::find_if(donnees.begin(), donnees.end(), [](int n) {
    return n % 11 == 0;
});
if (it_cond != donnees.end()) {
    std::cout << "Premier multiple de 11 : " << *it_cond << std::endl; // 55
}

1.2 Comptage : count et count_if

std::vector<int> notes = {12, 15, 12, 18, 12, 20};
// Compte le nombre de 12
int nb_douze = std::count(notes.begin(), notes.end(), 12); 

// Compte les notes supérieures ou égales à 15
int mentions = std::count_if(notes.begin(), notes.end(), [](int n) {
    return n >= 15;
});

1.3 Vérifications logiques : all_of, any_of, none_of

std::vector<int> test_valeurs = {2, 4, 6, 8};
bool tous_pairs = std::all_of(test_valeurs.begin(), test_valeurs.end(), [](int x) { return x % 2 == 0; });
bool un_negatif = std::any_of(test_valeurs.begin(), test_valeurs.end(), [](int x) { return x < 0; });

2. Algorithmes de transformation et modification

Ces outils modifient l'ordre ou la valeur des éléments au sein d'une séquence.

2.1 Copie sélective

std::vector<int> source = {1, 2, 3, 4, 5, 6};
std::vector<int> pairs;

// Copie uniquement les nombres pairs
std::copy_if(source.begin(), source.end(), std::back_inserter(pairs), [](int n) {
    return n % 2 == 0;
});

2.2 Transformation de données

std::transform applique une opération sur chaque élément et stocke le résultat dans une destination.

std::vector<int> Entree = {1, 2, 3, 4};
std::vector<int> Sortie;

// Elévation au cube
std::transform(Entree.begin(), Entree.end(), std::back_inserter(Sortie), [](int n) {
    return n * n * n;
});

2.3 Le mécanisme de suppression : remove et erase

L'algorithme remove ne supprime pas physiquement les éléments d'un conteneur (il déplace les éléments à conserver vers l'avant). Pour réduire la taille du conteneur, il faut utiliser la méthode erase.

std::vector<int> nombres = {1, 9, 2, 9, 3, 9};

// Déplace les '9' à la fin et retourne l'itérateur sur la nouvelle fin logique
auto nouvelle_fin = std::remove(nombres.begin(), nombres.end(), 9);

// Suppression réelle des éléments
nombres.erase(nouvelle_fin, nombres.end()); 
// nombres contient désormais {1, 2, 3}

2.4 Réorganisation : reverse et rotate

std::vector<int> seq = {1, 2, 3, 4, 5};
std::reverse(seq.begin(), seq.end()); // {5, 4, 3, 2, 1}

// Rotation : l'élément à l'index 2 devient le premier
std::rotate(seq.begin(), seq.begin() + 2, seq.end());

3. Tri et recherche binaire

Le tri est essentiel pour optimiser les recherches ultérieures.

3.1 Variantes de tri

• sort : Tri rapide (O(N log N)).
• stable_sort : Préserve l'ordre relatif des éléments équivalents.
• partial_sort : Trie uniquement les N preimers éléments.

std::vector<int> v = {5, 2, 8, 1, 9};
std::sort(v.begin(), v.end(), std::greater<int>()); // Tri décroissant

3.2 Recherche dans une séquence triée

std::vector<int> trie = {10, 20, 20, 30, 40};

// Vérifie l'existence
bool trouve = std::binary_search(trie.begin(), trie.end(), 20);

// Trouve la première position où on peut insérer 20 en gardant l'ordre
auto lb = std::lower_bound(trie.begin(), trie.end(), 20); // Itérateur sur le premier 20

4. Algorithmes numériques

Situés dans l'en-tête <numeric>, ils sont dédiés aux opérations mathématiques sur des plages de données.

#include <numeric>

std::vector<int> valeurs = {1, 2, 3, 4, 5};

// Somme totale (accumulate)
int somme = std::accumulate(valeurs.begin(), valeurs.end(), 0); // 15

// Remplissage séquentiel (iota)
std::vector<int> serie(5);
std::iota(serie.begin(), serie.end(), 100); // {100, 101, 102, 103, 104}

// Produit scalaire
std::vector<int> v1 = {1, 2}, v2 = {3, 4};
int dot_product = std::inner_product(v1.begin(), v1.end(), v2.begin(), 0); // (1*3)+(2*4) = 11

5. Opérations sur les ensembles

Ces algorithmes comparent deux séquences préalablement triées.

std::vector<int> set1 = {1, 2, 3, 4};
std::vector<int> set2 = {3, 4, 5, 6};
std::vector<int> intersection;

std::set_intersection(set1.begin(), set1.end(), 
                      set2.begin(), set2.end(), 
                      std::back_inserter(intersection));
// intersection contient {3, 4}