M1 MFMI. Algorithmique : feuille d`exercices no3. Exercice 1. Soit n

M1 MFMI. Algorithmique : feuille d’exercices no 3.
Exercice 1. Soit n ≥ 1 un entier. Si π est une permutation de {1, 2, . . . , , n}, on note c(π) le
nombre de cycles dans l’écriture de π comme produit de cycles disjoints, les éléments fixés étant
comptés des 1-cycles. Montrer que π s’écrit comme produit de n − c(π) transpositions. En déduire
que le nombre maximal d’échanges effectué en triant un tableau à n est n−1. Comparer ce résultat
avec celui de l’exercice 3 de la feuille 2 concernant le nombre minimal de tests de comparaison
nécessaires pour trier un tableau à n éléments.
Exercice 2. Étudier l’algorithme suivant pour trier un tableau T à n éléments d’un ensemble
totalement ordonné, les éléments de T étant supposés deux-à-deux distincts :
(1) on divise T en sous-tableaux T1 = T[[k1 ,k2 ]] , T2 = T[[k2 +1,k3 ]] , . . ., Tr−1 = T[[kr−1 ,kr ]] où k1 = 1
et k2 est le plus grand entier tel que le sous-tableau T[[k1 ,k2 ]] soit monotone, puis k3 est le plus
grand entier tel que le sous-tableau T[[k2 ,k3 ]] soit monotone (dans le sens opposé du précédent), et
ainsi de suite, et kr+1 = n ;
(2) on réécrit chacun les sous-tableaux Ti (1 ≤ i ≤ r − 1) par ordre croissant ;
(3) enfin, on intercale les sous-tableaux T1 et T2 pour obtenir un tableau T1,2 que l’on intercale
avec T3 et ainsi de suite, jusqu’à retrouver T trié.
Proposer des améliorations éventuelles de cet algorithme.
Exercice 3. Soit T un tableau à n éléments trié par ordre croissant. On suppose que les
éléments de T soient deux-à-deux distincts. Étudier la recherche par dichotomie, qui permet
de déterminer si un élément x appartient à T ou non, en le comparant d’abord avec T [bn/2c]
puis, si x 6= T [bn/2c], avec T [i], où i est l’entier le plus proche de 1+bn/2c
ou de bn/2c+n
selon que
2
2
x < T [bn/2c] ou x > T [bn/2c], et ainsi de suite.
(i ) Montrer en particulier que, si x ∈ E, alors l’algorithme déterminera si x ∈ T et, le cas
échéant, trouvera sa position après au plus dlog2 ne comparaisons. Vérifier que dans le pire des
cas ce nombre de comparaisons est effectivement nécessaire.
P
(ii ) Construire un algorithme de tri basé sur ce principe, qui utilisera au plus nk=1 dlog2 ke
tests de comparaison. On note cette quantité par B(n) (voir l’exercice 4).
Exercice 4. Soit n ≥ 1 un entier et soit (ai )1≤i≤n une suite finie de réels ou complexes.
(i ) Vérifier que
n
X
k=1
ak = nan −
n−1
X
k(ak+1 − ak ).
k=1
(ii ) En déduire que si b > 1 est un entier et si t = dlogb ne, alors
n
X
k=1
dlogb ke = ndlogb ne −
bt − 1
.
b−1
En particulier, si B(n) est la quantité définie dans l’exercice 3, on a B(n) = ndlog2 ne −
2dlog2 ne + 1.
(iii ) On pose S(n) = dlog2 n!e. À l’aide de l’exercice 3 de la feuille 2, montrer que tout
algorithme de tri par comparaison utilise au moins S(n) tests de comparaison. Montrer que S(n) ≤
B(n) quelque soit n ≥ 1.
(iv ) On constate que S(2) = B(2) = 1, S(3) = B(3) = 3, que S(4) = B(4) = 5 mais que
S(5) = 7 alors que B(5) = 8. Trouver une méthode de tri de tableaux à 5 éléments qui n’utilise
que 7 tests de comparaison au maximum.
(v ) Utiliser la formuleP
de la question
(i ) pour simplifier
d’autres sommes faisant intervenir les
√
P
n
n
3
fonctions b·c et d·e telles k=1 b kc et k=1 dlog2 4 k e.
Remarque. La méthode de la question (iv ) se généralise à tout n, fournissant un algorithme
(appelé parfois
ou algorithme de Ford-Johnson) dont le nombre de tests de compa
Pn insertion-fusion
3
raison est k=1 dlog2 4 k e, somme que nous désignereons par F (n). On trouve que F (n) = S(n)
quelque soit n ≤ 11 et pour n = 21, n = 22. L’algorithme est donc optimal (du point de vue du
nombre de tests de comparaison) pour ces valeurs de n. On a S(12) = 29 alors que F (n) = 30 et
on peut montrer (à l’aide de calculs sur ordinateur) qu’il n’y a pas de méthode de trier 12 objets
avec seulement 29 tests. Donc l’algorithme de Ford-Johnon est optimal aussi lorsque n = 12. Mais
on connaı̂t des valeurs de n pour lesquels cet algorithme n’est pas optimal, dont n = 47 est la
plus petite. En général, on ne connaı̂t pas le nombre minimal Smin (n) de comparaisons nécessaires
pour trier n objets. Bien évidemment, S(n) ≤ Smin (n) ≤ F (n) quelque soit n.