Vous êtes sur la page 1sur 13

la récursivité les fichiers

les méthodes de tri

1. Tri par bulle.

2. Tri par sélection.

3. Tri par insertion.

4.Tri par insertion binaire.

5. Tri rapide.

6. Tri par fusion.

********************************************************

Il existe plusieurs stratégies possibles pour trier les éléments d’un tableau .

soit le type

type tab= tableau [1.. 100] d’entiers

Et soit N la taille du tableau.

1. Tri par bulles.


Le tri à bulle consiste à parcourir le tableau, par exemple de gauche à droite, en comparant les
éléments adjacents et en les permutant si ils ne sont pas dans le bon ordre. Au cours d’une passe du
tableau, les plus grands éléments remontent de proche en proche vers la droite comme des bulles vers
la surface.

On s’arrête dés que l’on détecte que le tableau est trié : si aucune permutation n’a été faite au cours
d’une passe.

La stratégie de cet algorithme est comme suit :

1. Parcourir le tableau en comparant deux à deux les éléments successifs, permuter s'ils ne sont pas
dans l'ordre

2. Répéter tant que des permutations sont effectuées.

Algorithme :

procedure triBulle(var T : tab , N : entier) ;

déclaration

i ,temp; entier ;
Exemple :
trie : booléen
Trier par ordre croissant le tableau suivant :
début
1 5 3 2 7
trié← faux ;

tant que trie= faux faire // itération sur les


passages

trie← vrai ;
pour (i de 1 à N-1) faire

si (T[i] > T[i+1]) alors

temp <- T[i]; T[i] <- T[i+1]; T[i+1] <- temp;

trie ← faux;

finsi
Améliorer l’algorithme donné.
finpour

finTQ

FIN

2. Tri par sélection

Répéter

1. sélectionner le plus grand (le plus petit)


élément

2. le mettre à la fin (au début)

Algorithme

proédure Trier(var T: Tab,n :entier ) ;

déclaration

i , j, jmin: entier ;

début
Exemple :
Pour i de 1 à n-1 faire
Trier par ordre croissant le tableau suivant :
jmin ←i
1 5 3 2 7
Pour j de i+1 à n faire

Si T[j] < T[jmin] alors

jmin ← j;

FinSi

FinPour

Echanger(T[i], T[jmin])

FinPour
Ecrire la procedure echanger (T[i], T[jmin])
Fin

Remarque : le tri sélection utilise une variable de plus que le tri bulle pour stocker l'indice du plus
grand élément, mais il utilise moins d'instructions (une seule permutation par parcours du tableau)

3. Tri par Insertion

Dans ce cas, itérativement, nous insérons le prochain élément dans la partie qui est déjà triée
précédemment. La partie de départ qui est triée est le premier élément.

En insérant un élément dans la partie triée, il se pourrait qu’on ait à déplacer plusieurs autres.
Algorithme : i représente le nombre
d'éléments triés

procedure triInsertion(T : tab, N : entier) ;

déclaration

entier i, j, val;

debut

pour (i de 2 à N ) faire

val ← tab[i]; Exemple :

j ← i; Trier par ordre croissant le tableau suivant :

tantque ((j > 1) et (tab[j-1] > val)) faire 1 5 3 2 7

tab[j] ←tab[j-1];

j ←j-1;

fintantque

tab[j]← val;

finpour

fin

Remarque : le tri insertion est donc environ 2 fois plus rapide que le tri sélection

4. Tri par insertion binaire

Dans cette méthode nous cherchons d’une manière dichotomique la position de l’élément à insérer.

Algorithme :

Fonction RK ( var T : tab ; i , f : entier ; var z : entier) : entier ;


Déclaration

M : entier ;

début

Si i= f alors

Rk ← i

Sinon

m←( i +f )div 2;

si z < T[m] alors rk← rk ( T , I , m, z)

else rk←rk (T, m+1, f , z) ;

FinSi

FinSI

Fin

Procedure Tinsbin( var T: tab; N: entier) ;

Déclaration

J , k, z : entier ;

Début

Si N > 1 alors

Tinsbin ( T , n-1) ;

Si T [ N-1] > T[N] alors

K ← rk (T , 1, N-1 , T [ N]) ;

Pour j de N-1 à k faire


T [ j +1] ← T[j] ;

T[ k] ← z Fin pour

FinSI

FinSi

FIN

5. Le tri rapide

- on prend le premier élément (le pivot),

- on le met à sa place en plaçant à sa gauche les éléments plus petits que lui et à sa droite les
éléments plus grands que lui.

- Puis on répète l'opération d'une part sur le sous tableau de gauche, d'autre part sur le sous-
tableau de droite.

Algorithme : on partitionne le tableau autour de la valeur contenue dans la première case, puis on
appelle l'algorithme sur chacune des sous-parties. Il nous faut donc :

*Une fonction qui partitionne une certaine section [a,b] du tableau en plaçant au début les éléments
plus petits que tab[a], puis tab[a], puis les éléments plus grands ou égaux à tab[a] et retourne l'indice
de tab[a] dans le tableau partitionné

(au départ, a vaudra 0 et b vaudra tab.longueur-1)

*Une procédure de tri proprement dit qui appelle la fonction précédente puis lance des appels
récursifs sur les sous-parties
onction partition(T : tab, a :entier, b :entier) :
entier ; Exemple :trier le tableau suivant :

déclaration

pivot,i,temp : entier;

début

pivot ← a;

pour i de a+1 à b faire

si (T[i] < T[pivot]) alors

temp ← T[i];

T[i] ← T[pivot+1];

T[pivot+1] ← T[pivot];
T[pivot]← temp;

pivot ← pivot+1;

finsi

finpour

partition← pivot;

fin ;

procédure triRapide(T : tab, a, b : entier) ;

déclaration

pivot : entier;

début

si (b > a) alors

pivot ← partition(T,a,b);

triRapide(T,a,pivot-1);

triRapide(T,pivot+1,b);

finsi
70 17 2 201 415 45 45 102
fin ;
6. Tri par fusion :

Principe du tri fusion : on découpe le tableau en deux, on trie chacune des 2 parties, puis on fusionne
les parties triées en respectant l'ordre.

Algorithme : il nous faut donc une procédure qui fusionne deux sections contigües du tableau. Le
plus simple est d'utiliser des tableaux supplémentaires (mais il est possible de faire du tri fusion en
place).

une procédure de tri proprement dit qui lance des appels récursifs sur les sous parties puis appelle la
procédure précédente.

Procédure fusion(T : tab, a, b, c : entier) ;

déclaration

i,j,k : entier;

T1 : tableau[1..b-a+1]d’entier; T2 : tableau[1.. c-b] d’entier;

début

pour (i de 0 à t1.longueur-1 ) faire t1[i] ← T[a+i]; finpour

pour (j de 0 à t2.longueur-1) faire t2[j] ← T[b+1+j]; finpour

i ←0; j ← 0; k←a;

tantque (k < = c) faire

si (i > = t1.longueur) alors


T[k] ←t2[j]; j ← j+1

sinon

si (j > = t2.longueur) alors

T[k] ← t1[i]; i ← i+1

sinon

si (t1[i] < = t2[j]) alors

T[k] ←t1[i]; i ß i+1

sinon

T[k] ← t2[j]; j ← j+1;

finsi

finsi

finsi

k← k+1;

fintantque

fin ;

Procédure triFusion(T : tab ; a, b : entier)

début

si (b>a) alors

triFusion(tab,a,(a+b)/2);

triFusion(tab,((a+b)/2)+1,b);

fusion(tab,a,(a+b)/2,b);
finsi

fin ;

Exemple : trier le tableau suivant :

3 5 6 7 20

Vous aimerez peut-être aussi