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

M1 MFMI. Algorithmique : feuille d’exercices no3.
Exercice 1. Soit n≥1 un entier. Si πest une permutation de {1,2,...,,n}, on note c(π) le
nombre de cycles dans l’´ecriture de πcomme produit de cycles disjoints, les ´el´ements fix´es ´etant
compt´es des 1-cycles. Montrer que πs’´ecrit comme produit de n−c(π) transpositions. En d´eduire
que le nombre maximal d’´echanges effectu´e en triant un tableau `a nest n−1. Comparer ce r´esultat
avec celui de l’exercice 3 de la feuille 2 concernant le nombre minimal de tests de comparaison
n´ecessaires pour trier un tableau `a n´el´ements.
Exercice 2.´ Etudier l’algorithme suivant pour trier un tableau T`a n´el´ements d’un ensemble
totalement ordonn´e, les ´el´ements de T´etant suppos´es deux-`a-deux distincts :
(1) on divise Ten sous-tableaux T1=T[[k1,k2]],T2=T[[k2+1,k3]], . . ., Tr−1=T[[kr−1,kr]] o`u k1= 1
et k2est le plus grand entier tel que le sous-tableau T[[k1,k2]] soit monotone, puis k3est le plus
grand entier tel que le sous-tableau T[[k2,k3]] soit monotone (dans le sens oppos´e du pr´ec´edent), et
ainsi de suite, et kr+1 =n;
(2) on r´e´ecrit chacun les sous-tableaux Ti(1 ≤i≤r−1) par ordre croissant ;
(3) enfin, on intercale les sous-tableaux T1et T2pour obtenir un tableau T1,2que l’on intercale
avec T3et ainsi de suite, jusqu’`a retrouver Ttri´e.
Proposer des am´eliorations ´eventuelles de cet algorithme.
Exercice 3. Soit Tun tableau `a n´el´ements tri´e par ordre croissant. On suppose que les
´el´ements de Tsoient deux-`a-deux distincts. ´ Etudier la recherche par dichotomie, qui permet
de d´eterminer si un ´el´ement xappartient `a Tou non, en le comparant d’abord avec T[bn/2c]
puis, si x6=T[bn/2c], avec T[i], o`u iest l’entier le plus proche de 1+bn/2c
2ou de bn/2c+n 2selon que
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´eterminera si x∈Tet, le cas
´ech´eant, trouvera sa position apr`es au plus dlog2necomparaisons. V´erifier que dans le pire des
cas ce nombre de comparaisons est effectivement n´ecessaire.
(ii) Construire un algorithme de tri bas´e sur ce principe, qui utilisera au plus Pn
k=1 dlog2ke
tests de comparaison. On note cette quantit´e par B(n) (voir l’exercice 4).
Exercice 4. Soit n≥1 un entier et soit (ai)1≤i≤nune suite finie de r´eels ou complexes.
(i) V´erifier que
n
X
k=1
ak=nan−
n−1
X
k=1
k(ak+1 −ak).
(ii) En d´eduire que si b > 1 est un entier et si t=dlogbne, alors
n
X
k=1 dlogbke=ndlogbne − bt−1
b−1.
En particulier, si B(n) est la quantit´e d´efinie dans l’exercice 3, on a B(n) = ndlog2ne −
2dlog2ne+ 1.
(iii) On pose S(n) = dlog2n!e.` A 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´ethode de tri de tableaux `a 5 ´el´ements qui n’utilise
que 7 tests de comparaison au maximum.
(v) Utiliser la formule de la question (i) pour simplifier d’autres sommes faisant intervenir les
fonctions b·c et d·e telles Pn
k=1 b√kcet Pn k=1 dlog23
4ke.
Remarque. La m´ethode de la question (iv ) se g´en´eralise `a tout n, fournissant un algorithme
(appel´e parfois insertion-fusion ou algorithme de Ford-Johnson) dont le nombre de tests de compa-
raison est Pn
k=1 dlog23
4ke, somme que nous d´esignereons 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 (`a l’aide de calculs sur ordinateur) qu’il n’y a pas de m´ethode 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 npour lesquels cet algorithme n’est pas optimal, dont n= 47 est la
plus petite. En g´en´eral, on ne connaˆıt pas le nombre minimal Smin(n) de comparaisons n´ecessaires
pour trier nobjets. Bien ´evidemment, S(n)≤Smin(n)≤F(n) quelque soit n.