Correction – borne inférieure sur la complexité du tri

Université Paris Diderot – Paris 7
L3 Informatique
Algorithmique
Année 2009-2010, 1er semestre
Correction – borne inférieure sur la complexité du tri
Il fallait “bien entendu” lire n(log2 n − 2) plutôt que n(ln n − 1). . .
Exercice 1 [Permutations]
1. Un algorithme pour trier des tableaux quelconques est en particulier capable de trier des tableaux
de n éléments distincts parmi {1, . . . , n}. Donc la borne inférieure en n(log n − 2) s’applique à eux
aussi.
2. Donc si on montre une borne inférieure pour les tableaux de n éléments distincts parmi {1, . . . , n},
on aura une borne inférieure générale pour le tri d’un tableau.
Exercice 2 [Arbre des comparaisons]
Question 1.
1. Arbre des comparaisons pour le tri par insertion pour les tableaux de taille 2 et 3 :
T [1] < T [2]?
T [2] < T [3]?
T [1] < T [2]?
•
T [1] < T [2]?
T [2] < T [3]?
•
T [1] < T [2]?
• •
• •
• •
On décrit l’arbre An+1 pour les tableaux de taille n + 1 à partir de l’arbre An pour les tableaux de
taille n : à chaque feuille de l’arbre An , on ajoute la comparaison T [n] < T [n + 1]? ; son fils gauche
est une feuille (pas de comparaison) et son sous-arbre droit est une copie de An .
2. Arbre des comparaisons pour le tri à bulles pour les tableaux de taille 2 et 3 :
T [1] < T [2]?
T [2] < T [3]?
T [1] < T [2]?
T [1] < T [2]?
T [1] < T [2]?
T [2] < T [3]?
T [1] < T [2]?
T [1] < T [2]?
• •
• •
• •
• •
• •
On décrit l’arbre An+1 pour les tableaux de taille n + 1 à partir de l’arbre An pour les tableaux
de taille n : An+1 consiste d’abord en un un arbre complet où au niveau i on fait les comparaisons
T [i] < T [i + 1] pour i = 1 à n ; puis à chaque feuille on ajoute l’arbre An .
Question 2.
1. La suite des comparaisons effectuées sur un tableau donné détermine un chemin dans l’arbre, donc
une branche.
1
2. Non puisqu’il peut y avoir des tests inutiles. Par exemple, pour le tri à bulles, la branche T [1] < T [2]
puis T [2] < T [3] puis T [1] > T [2] n’est pas possible (il n’y a pas eu d’échanges donc à la fin, on a
toujours T [1] < T [2]).
3. Si deux tableaux distincts correspondaient à la même branche, alors l’algorithme effectuerait exactement la même chose sur les deux tableaux (échange des éléments, etc.). Puisqu’ils sont distincts
au départ, on aboutirait donc à deux tableaux distincts, or ce n’est pas le cas puisqu’à la fin on
aboutit toujours au tableau [1, 2, . . . , n].
4. Pour les deux feuilles de l’arbre du tri par insertion pour les tableaux à 2 éléments, les étiquettes
sont : [1, 2] et [2, 1].
Pour les tableaux à 3 éléments : [1, 2, 3], [1, 3, 2], [2, 3, 1], [2, 1, 3], [3, 1, 2] et [3, 2, 1]
Pour les deux feuilles de l’arbre du tri à bulles pour les tableaux à 2 éléments, les étiquettes sont :
[1, 2] et [2, 1].
Pour les tableaux à 3 éléments : la deuxième et la sixième feuille ne correspondent pas à des
exécutions valides. Pour les autres feuilles : [1, 2, 3], [1, 3, 2], [2, 3, 1], [2, 1, 3], [3, 1, 2] et [3, 2, 1]
5. On peut supprimer les feuilles non étiquetées puisqu’elles ne correspondent pas à des exécutions
valides de l’algorithme.
Exercice 3 [Déroulement d’un algorithme]
1. Tous les tableaux possibles doivent se retrouver aux feuilles de l’arbre puisque l’algorithme doit être
capable de tous les trier.
2. Le nombre de comparaisons effectuées par l’algorithme sur un tableau donné correspond à la longueur de la branche correspondant à ce tableau. Puisque la hauteur de l’arbre est la longueur
maximale d’une branche, il s’agit bien du nombre de comparaisons dans le pire cas.
3. Un arbre binaire de hauteur h possède au maximum 2h feuilles. Preuve par récurrence sur h : vrai
pour h = 0 (1 feuille). Pour un arbre de hauteur h+1 : la racine possède deux sous-arbres de hauteur
≤ h donc ils ont au plus 2h feuilles chacun. En tout, l’arbre de hauteur h + 1 a ≤ 2 × 2h = 2h+1
feuilles.
4. Il faut exactement une feuille par tableau de n éléments distincts parmi {1, . . . , n}, c’est-à-dire n!
(factorielle n).
n
5. On doit donc avoir 2h ≥ n!. D’après la formule de Stirling, pour n assez grand on a n! ≥ ne .
Donc h ≥ log2 (n!) ≥ n(log2 n − log2 e). Puisque log2 (e) = 1/ ln 2 ≤ 2, on a bien que la hauteur de
l’arbre, donc le nombre de comparaisons effectuées par l’algorithme dans le pire cas, est au moins
n(log2 n − 2).
Exercice 4 [Un tri linéaire ?]
1. Puisque toutes les valeurs de T sont comprises entre 1 et k, on peut créer un tableau A de taille k
et remplir la case i de A par le nombre d’occurences de i dans T .
Puis pour trier T , on parcourt le tableau A dans l’ordre et pour la case i on écrit dans T (à la suite)
toutes les occurences de i. À chaque étape, soit on avance d’une case dans A, soit on avance d’une
case dans T . Ainsi il y a k + n étapes, chacune en temps constant. Donc la complexité est O(k + n).
2. Si k ≤ n, on a donc un tri en O(n), linéaire.
3. Non car ce tri n’est pas fondé sur des comparaisons et est donc exclu de notre modèle : on connaît
a priori la forme des entrées et on peut donc tester si elles sont égales à une certaine valeur, plutôt
que des les comparer entre elles.
Noter qu’en particulier, cet algorithme ne trie pas en temps linéaire des tableaux quelconques : dès
que k 6∈ O(n), ce tri n’est plus linéaire.
2