← Retour au sommaire

Chapitre 25 – Algorithmique appliquée

Exercices par capacités · BTS

Dernière mise à jour : 21 juin 2026

Capacités travaillées

C1 — Appliquer et comparer les algorithmes de recherche

Exercice 1

On effectue une recherche séquentielle de la valeur 8 dans le tableau \(t = [5, 3, 8, 1, 9, 2]\) (indices à partir de 0). Indiquer les comparaisons effectuées et l'indice retourné.

On parcourt le tableau de gauche à droite :

  • \(t[0]=5 \neq 8\)
  • \(t[1]=3 \neq 8\)
  • \(t[2]=8 = 8\) → trouvé.

3 comparaisons sont effectuées ; l'algorithme retourne l'indice 2.

Exercice 2

On recherche la valeur 8 dans le tableau trié \(t = [1, 2, 3, 5, 8, 9]\) par recherche dichotomique. Détailler chaque étape (calcul du milieu, comparaison).

Le tableau a 6 éléments, indices 0 à 5.

  • gauche=0, droite=5 → milieu \(=(0+5)//2 = 2\), \(t[2]=3 < 8\) → chercher à droite, gauche=3.
  • gauche=3, droite=5 → milieu \(=(3+5)//2 = 4\), \(t[4]=8 = 8\) → trouvé.

2 comparaisons suffisent ; l'algorithme retourne l'indice 4.

Exercice 3

On recherche la valeur 7 (absente) dans le tableau trié \(t = [1, 2, 3, 5, 8, 9]\) par dichotomie. Détailler les étapes et donner la valeur retournée.

  • gauche=0, droite=5 → milieu=2, \(t[2]=3 < 7\) → gauche=3.
  • gauche=3, droite=5 → milieu=4, \(t[4]=8 > 7\) → droite=3.
  • gauche=3, droite=3 → milieu=3, \(t[3]=5 < 7\) → gauche=4.
  • gauche=4 > droite=3 → la boucle s'arrête.

La valeur n'a pas été trouvée : l'algorithme retourne -1.

Exercice 4

Pour un tableau trié de \(n = 1\,000\,000\) éléments, comparer le nombre maximal de comparaisons d'une recherche séquentielle et d'une recherche dichotomique.

Recherche séquentielle : pire cas \(O(n)\), soit jusqu'à 1 000 000 comparaisons.

Recherche dichotomique : pire cas \(\lceil\log_2 n\rceil\). Or \(\log_2(10^6) \approx 19{,}9\), donc \(\lceil\log_2(10^6)\rceil = 20\). Soit au maximum 20 comparaisons.

La dichotomie est radicalement plus efficace, mais elle exige un tableau préalablement trié.

C2 — Dérouler et comparer les algorithmes de tri

Exercice 5

Dérouler la première passe du tri à bulles sur le tableau \([5, 3, 1, 4, 2]\). Indiquer chaque comparaison, l'échange éventuel et l'état du tableau à la fin de la passe.

On compare les éléments adjacents et on échange si le gauche est plus grand.

  • \(5 > 3\) → échange : \([3, 5, 1, 4, 2]\)
  • \(5 > 1\) → échange : \([3, 1, 5, 4, 2]\)
  • \(5 > 4\) → échange : \([3, 1, 4, 5, 2]\)
  • \(5 > 2\) → échange : \([3, 1, 4, 2, 5]\)

À la fin de la passe 1, le plus grand élément (5) est en dernière position : \([3, 1, 4, 2, \mathbf{5}]\).

Exercice 6

Dérouler le tri par sélection sur \([4, 2, 7, 1]\). À chaque tour, indiquer le minimum sélectionné et l'état du tableau après échange.

  • Tour 1 : minimum de \([4,2,7,1]\) est 1 (indice 3) → échange avec l'indice 0 : \([1, 2, 7, 4]\).
  • Tour 2 : minimum de \([2,7,4]\) est 2 (déjà en place) → \([1, 2, 7, 4]\).
  • Tour 3 : minimum de \([7,4]\) est 4 → échange : \([1, 2, 4, 7]\).

Tableau trié : \([1, 2, 4, 7]\).

Exercice 7

On applique l'algorithme de tri rapide (quicksort) au tableau \([3, 7, 1, 5]\) en choisissant le dernier élément comme pivot. Effectuer la première partition et donner l'indice final du pivot.

Pivot = dernier élément = 5. On place à gauche les éléments \(\leq 5\).

  • \(3 \leq 5\) → reste à gauche : \([3, 7, 1, 5]\).
  • \(7 > 5\) → reste à droite.
  • \(1 \leq 5\) → échange avec le 7 : \([3, 1, 7, 5]\).
  • Fin : on place le pivot après les éléments \(\leq 5\) : échange du pivot avec le 7 → \([3, 1, 5, 7]\).

Le pivot 5 est à l'indice 2. À gauche : \([3, 1]\) (tous \(\leq 5\)) ; à droite : \([7]\). On trie ensuite récursivement chaque partie.

Exercice 8

Compléter le tableau comparatif des complexités (pire cas) et indiquer si le tri est stable.

AlgorithmePire casStable ?
Tri à bulles??
Tri par sélection??
Tri rapide??
Tri fusion??
AlgorithmePire casStable ?
Tri à bulles\(O(n^2)\)Oui
Tri par sélection\(O(n^2)\)Non
Tri rapide\(O(n^2)\)Non
Tri fusion\(O(n\log n)\)Oui

Le tri rapide est \(O(n\log n)\) en moyenne mais \(O(n^2)\) au pire (mauvais choix de pivot). Le tri fusion garantit \(O(n\log n)\) dans tous les cas.

C3 — Utiliser les structures de données linéaires et la récursivité

Exercice 9

On effectue sur une pile (LIFO) initialement vide la séquence d'opérations : push(10), push(20), push(30), pop(), push(40), pop(). Donner la valeur retournée par chaque pop() et l'état final de la pile.

Dans une pile, c'est le dernier élément empilé qui est retiré en premier (LIFO).

  • push(10), push(20), push(30) → pile = [10, 20, 30] (sommet : 30).
  • pop() → retourne 30 ; pile = [10, 20].
  • push(40) → pile = [10, 20, 40].
  • pop() → retourne 40 ; pile = [10, 20].

État final de la pile : [10, 20] (sommet : 20).

Exercice 10

On effectue sur une file (FIFO) initialement vide : enqueue("A1"), enqueue("A2"), enqueue("A3"), dequeue(), enqueue("A4"), dequeue(). Donner la valeur retournée par chaque dequeue() et l'état final de la file.

Dans une file, c'est le premier élément enfilé qui est retiré en premier (FIFO).

  • enqueue A1, A2, A3 → file = [A1, A2, A3] (tête : A1).
  • dequeue() → retourne "A1" ; file = [A2, A3].
  • enqueue A4 → file = [A2, A3, A4].
  • dequeue() → retourne "A2" ; file = [A3, A4].

État final de la file : [A3, A4] (tête : A3).

Exercice 11

On considère la fonction récursive de la factorielle :

def factorielle(n):
    if n == 0:
        return 1
    return n * factorielle(n - 1)
  1. Identifier le cas de base et l'appel récursif.
  2. Dérouler l'arbre d'appels pour factorielle(4) et donner le résultat.
  1. Cas de base : \(n = 0\) renvoie 1. Appel récursif : n * factorielle(n-1) sur un problème plus petit.
  2. Déroulé : \(4! = 4 \times 3! = 4 \times (3 \times 2!) = 4 \times 3 \times (2 \times 1!) = 4 \times 3 \times 2 \times (1 \times 0!) = 4 \times 3 \times 2 \times 1 \times 1\).

Résultat : \(4! = 24\).

Exercice 12

La suite de Fibonacci est définie par \(F(0)=0\), \(F(1)=1\) et \(F(n) = F(n-1) + F(n-2)\).

  1. Calculer \(F(2), F(3), \ldots, F(7)\).
  2. Pourquoi la version récursive naïve est-elle déconseillée pour les grandes valeurs de \(n\) ?
  1. \(F(2)=1\), \(F(3)=2\), \(F(4)=3\), \(F(5)=5\), \(F(6)=8\), \(F(7)=13\).
  2. La récursion naïve recalcule de nombreuses fois les mêmes valeurs : sa complexité est \(O(2^n)\). On préfère la version itérative ou avec mémoïsation, en \(O(n)\).
Exercice 13

Pour les tours de Hanoï, le nombre de déplacements nécessaires pour \(n\) disques est \(2^n - 1\).

  1. Combien de déplacements pour 3 disques ? Pour 5 disques ?
  2. Combien de déplacements pour 10 disques ?
  1. 3 disques : \(2^3 - 1 = 8 - 1 = 7\) déplacements. 5 disques : \(2^5 - 1 = 32 - 1 = 31\) déplacements.
  2. 10 disques : \(2^{10} - 1 = 1024 - 1 = 1023\) déplacements.

C4 — Analyser la complexité algorithmique avec la notation Big-O

Exercice 14

Donner la complexité Big-O de chaque expression en ne gardant que le terme dominant :

  1. \(3n^2 + 5n + 2\)
  2. \(7n + 100\)
  3. \(2n^3 + 50n^2 + n\)
  4. \(4\log_2 n + 8\)

On ne garde que le terme à croissance la plus rapide et on ignore les constantes.

  1. \(3n^2 + 5n + 2 \in O(n^2)\).
  2. \(7n + 100 \in O(n)\).
  3. \(2n^3 + 50n^2 + n \in O(n^3)\).
  4. \(4\log_2 n + 8 \in O(\log n)\).
Exercice 15

Classer les complexités suivantes par ordre de croissance (de la plus lente à la plus rapide à croître) : \(O(n^2)\), \(O(1)\), \(O(n\log n)\), \(O(\log n)\), \(O(2^n)\), \(O(n)\).

Ordre croissant des complexités :

\(O(1) \ll O(\log n) \ll O(n) \ll O(n\log n) \ll O(n^2) \ll O(2^n)\).

\(O(1)\) (constante) croît le plus lentement, \(O(2^n)\) (exponentielle) le plus vite.

Exercice 16

Justifier que la recherche dichotomique sur un tableau trié de taille \(n\) effectue au plus \(\lceil\log_2 n\rceil\) comparaisons.

À chaque comparaison, la taille du sous-tableau à explorer est divisée par 2. Après \(k\) étapes, cette taille vaut \(\dfrac{n}{2^k}\).

La recherche s'arrête lorsque \(\dfrac{n}{2^k} \leq 1\), c'est-à-dire \(2^k \geq n\), soit \(k \geq \log_2 n\).

Le nombre d'étapes est donc au plus \(\lceil\log_2 n\rceil\), d'où une complexité \(O(\log n)\).

Exercice 17

Un algorithme parcourt un tableau de taille \(n\) avec deux boucles imbriquées (chaque boucle de 0 à \(n-1\)).

  1. Combien d'opérations élémentaires effectue-t-il ? Quelle est sa complexité ?
  2. Pour \(n = 1000\), estimer le nombre d'opérations.
  1. Deux boucles imbriquées de \(n\) itérations chacune effectuent \(n \times n = n^2\) opérations : complexité \(O(n^2)\) (quadratique).
  2. Pour \(n = 1000\) : \(n^2 = 10^6 = 1\,000\,000\) opérations.
Exercice 18

On distingue la complexité temporelle et la complexité spatiale. Pour le tri fusion et un tri en place (comme le tri par sélection), indiquer la complexité spatiale (mémoire supplémentaire) et expliquer la différence.

La complexité temporelle mesure le nombre d'opérations ; la complexité spatiale mesure la mémoire supplémentaire utilisée.

  • Tri fusion : il fusionne des sous-tableaux dans des tableaux temporaires, d'où une complexité spatiale \(O(n)\).
  • Tri en place (par sélection) : il n'utilise que quelques variables auxiliaires (indices, valeur d'échange), d'où une complexité spatiale \(O(1)\).

Le tri en place est préférable lorsque la mémoire est limitée, même si le tri fusion offre une meilleure garantie temporelle.