Algorithmie PC 2 : Tris corrigé 1 Tri par bulles

Algorithmie
PC 2 : Tris
corrig´e
1 Tri par bulles
1.1 Principe du tri par Bulles (variante du tri par s´election)
On consid`ere un tableau tab de ndonn´ees sur lesquelles il existe une relation
d’ordre. On souhaite trier ce tableau dans l’ordre croissant.
Pour cela, on r´ealise autant de passes sur les donn´ees que n´ecessaire en
´echangeant les ´el´ements adjacents s’ils sont dans un mauvais ordre relatif :
parcourir tab[0], ..., tab[n-1] en intervertissant les ´el´ements tab[j-1] et
tab[j] non ordonn´es pour tout 1≤j≤n−1.
1.2
´
Ecrire un algorithme mettant en œuvre la m´ethode d´ecrite.
Algorithme 1 Tri par bulles
Donn´ees
tab
n
D´ebut
changement=Vrai
Tant que changement = Vrai faire
changement = Faux
de i =1 an-2 faire
Si tab[i-1] >tab[i] alors
tempo = tab[i-1]
tab[i-1] = tab[i]
tab[i] =tempo
rendre tab Fin
1

1.3
Tester l’algorithme sur le tableau tab=[10, 7, 8, 4, 5]
L’ex´ecution de l’algorithme est r´esum´e en table 1.
tab[0] tab[1] tab[2] tab[3] tab[4] boucle tant que i
10 7 8 4 5 1 1
710 8 4 5 2
7 8 10 4 5 3
78410 5 4
7 8 4 5 10
7 8 4 5 10 2 1
78 4 5 10 2
7 4 8 5 10 3
7458 10 4
7 4 5 8 10
7 4 5 8 10 3 1
47 5 8 10 2
4 5 7 8 10 3
4578 10 4
4 5 7 8 10
4 5 7 8 10 4 1
45 7 8 10 2
4 5 7 8 10 3
4578 10 4
4 5 7 8 10
Table 1: Ex´ecution du tri bulle avec tab=[10, 7, 8, 4, 5]
1.4
Expliquer pourquoi le tri par bulles est bien une m´ethode de tri ?
Combien de passes sont-elles n´ecessaires pour trier le tableau ?
C’est bien une m´ethode de tri (ouf) car `a chaque passe un nouvel ´el´ement
sera tri´e et ne changera plus de place. Plus pr´ecis´ement :
•lors de la premi`ere passe, l’´el´ement de plus grande valeur est ´echang´e
avec chacun des ´el´ements situ´es `a sa droite (i.e. les ´el´ements d’indices
sup´erieurs) jusqu’`a ce qu’il se trouve `a sa place d´efinitive, (`a l’extr´emit´e
droite du tableau en tab[n-1]),
•`a la seconde passe, c’est l’´el´ement de seconde plus grande valeur qui est
mis `a sa place d´efinitive,
•et ainsi de suite . . .
Il y a donc au maximum n passes `a effectuer.
2

1.5
Quel est la complexti´e de cet algorithme ?
Il y a au maximum nboucles “tant que” et dans chaque boucle “tant que”
un parcours de tous les ´el´ements du tableau et des op´erations en O(1). La
complexit´e est donc en O(n2).
1.6
Y a-t-il des am´eliorations possibles `a notre algorithme ?
Comme on sait que `a la fin de la passe iles iderni`eres positions du tableau
sont tri´es, il n’est pas n´ecessaire de les consulter. Cela ne changera pas la com-
plexit´e th´eorique (en O(n2)) mais r´eduira tout de mˆeme le nombre d’op´erations
effectu´ees.
1.7
Pour quelles types de donn´ees cet algorithme est-il efficace ?
Pour des donn´ees presque (ou d´ej`a) tri´ees.
2 Tri rapide
Le tri rapide (quicksort pour les anglicistes) est certainement le tri le plus utilis´e,
et ceci pour plusieurs raisons, en particulier :
•facile `a impl´ementer,
•efficace pour de nombreux types de donn´ees,
•peu gourmand en ressources.
Cependant, il comporte aussi des d´efauts, en particulier il est r´ecursif et
donc une petite erreur de programmation peut se r´ev´eler d´esastreuse et difficile
`a corriger, il effectue un nombre quadratique d’op´erations dans le pire des cas
(nlog(n) op´erations en moyenne comme vous allez le calculer).
2.1 Algorithme
L’algorithme 2 est une impl´ementation du tri rapide. Lancer l’algorithme
sur le tableau pr´ec´edent ([10, 7, 8, 4, 5]). Pourquoi est-ce une
m´ethode de tri ?
Les variables gauche et droite sont les bornes dans lesquelles le tableau sera
tri´e. Le principe de l’algorithme est, entre les bornes, de choisir un ´el´ement
(pivot) que l’on va placer `a l’endroit qu’il occupera lorsque les donn´ees seront
tri´ees. Pour cela, on s’arrange pour qu’`a gauche de pivot tous les ´el´ements soient
plus petit que lui et qu’`a droite tous les ´el´ements soient plus grand que lui.
Une fois ceci fait, on relance l’algorithme pour les parties `a gauche et `a droite
de pivot.
3

Algorithme 2 Tri rapide. Initialis´e par gauche=0 et droite=n-1
Donn´ees
tab
gauche
droite
D´ebut
Si droite >gauche alors
stop = Faux
i = gauche
j = droite-1
pivot = tab[droite]
Tant que stop = Faux faire
(1) tant que tab[i] <pivot faire
i = i+1
(2) tant que tab[j] >pivot faire
j = j-1
Si i≥jalors
stop = vrai
Sinon
(3) tempo = tab[i]
tab[i] = tab[j]
tab[j] = tempo
(4) i=i+1
j=j-1
(5) tempo = tab[i]
tab[i] = tab[droite]
tab[droite] = tempo
(6) triRapide(tab, gauche,i-1)
(7) triRapide(tab, i+1,droite)
rendre tab Fin
4

Plus pr´ecis´ement, `a la fin de (1) et (2) i pointe sur la premi`ere occurrence du
tableau apr`es gauche plus grande que pivot et j sur la plus grande occurrence
du tableau avant droite plus petite que pivot.
Si i<j, toute les valeurs n’ont pas ´et´e regard´ees et on peu ´echanger tab[i]
et tab[j] (´etape (3)) pour agrandir notre recherche (apr`es l’´echange, tous les
´el´ements plus petit que i sont <que pivot et tous les ´el´ements plus grand que j
sont >pivot. Avant l’´echange tab[i]=>pivot et tab[j]<=pivot). On peut donc
r´eit´erer les ´etapes (1) et (2).
Une fois que i>=j, tous les ´el´ements entre gauche et droite ont ´et´e vus, et,
tous les ´el´ements de gauche `a i-1 sont plus petit ou ´egaux `a pivot et tous les
´el´ements entre i et droite sont plus grand ou ´egaux `a pivot. L’´echange entre
tab[i] et tab[droite] (´etape 5) nous assure donc que la place de la valeur pivot
restera inchang´ee `a la suite du tri (c’est `a dire que l’on peut trouver un tri du
tableau o`u la valeur de tab[i] sera pivot).
Il ne nous reste plus qu’`a trier les bouts de tableaux restant, c’est `a dire les
´el´ements entre gauche et i-1 (´etape 6) et ceux entre i+1 et droite (´etape 7).
2.2
Cette m´ethode de tri est-elle stable ?
Non, car la position finale du pivot ne peut ˆetre connue et donc il n’y a
aucune raison que la m´ethode soit stable.
2.3
Quelle est la complexit´e (au pire) de cet algorithme ?
`
A chaque ´etape, un ´el´ement est tri´e. Tri Rapide est donc lanc´e au maximum
nfois. La complexit´e de la boucle “tant que stop=Faux” incr´emente deux
compteur i et j, et s’arrˆete lorsque i≥j. Le nombre d’op´erations est donc de
l’ordre de O(n). La complexit´e finale de l’algorithme est donc en O(n2).
2.4
Complexit´e moyenne
La formule de r´ecurrence de la complexit´e moyenne peut ˆetre construite
comme suit : C(N) = “op´erations de la boucle tant que stop=Faux” + “moyenne
du nombre d’op´erations effectu´e par les deux appels r´ecursifs”
La premi`ere partie est lin´eaire, on peut donc la borner par p.N o`u p est une
constante quelque soit N.
Pour la deuxi`eme partie, la taille des tableaux qui vont ˆetre pass´es aux appels
r´ecursifs n’est pas connue, et d´epend de la position finale du pivot. Si c’est la
position kdu tableau qui est la position finale du pivot, le nombre d’op´erations
effectu´es par ces appels est C(k-1) + C(N-k). Chaque case du tableau ayant
une probabilit´e 1/N d’ˆetre la position finale du tableau, donc le nombre moyen
d’op´erations est : (1/N )∗P1≤k≤N(C(k−1) + C(N−k)).
5