Vous êtes sur la page 1sur 4

Chapitre3: les algorithmes de tri ~ Résumé des algorithmes de tri 4ème Sciences de l’informatique

Tri par sélection


Principe Version itérative Version récursive
Procedure Tri_Selection(var T:tab ; N:entier) Procedure Tri_Selection_Rec(var T:tab; i,N:entier)
Résultat: T_trié Résultat: Tri_Selection_Rec
T: Pour i de 1 à N-1 faire Si (i < N) alors
ppm  FN PrePosMin(T,i,N) ppm  FN PrePosMin(T,i,N)
Si T[i] <> T [ppm] alors Si (T[i] <> T [ppm]) alors
Proc Permut(T[i],v[ppm]) Proc Permut(T[i],T[ppm])
Fin Si Fin Si
Fin pour Proc Tri_Selection_Rec(T,i+1,N)
Fin selection Fin Si
Fin Tri_Selection_Rec
Fonction PrePosMin(T :tab ; i,N:entier) :entier
Résultat: PrePosMinmin Fonction PrePosMin(T :tab ; i,N:entier) :entier
Min:[mini ] Résultat: PrePosMinmin
Le principe du tri par sélection est d'aller Pour j de i+1 à N faire Min:[mini ]
chercher le plus petit/grand élément du Si T[j] < T[min] alors Pour j de i+1 à N faire
vecteur pour le mettre en premier, puis de min  j Si T[j] < T[min] alors
repartir du second élément et d'aller Fin Si min  j
Fin Pour Fin Si
chercher le plus petit/grand élément du
Fin PrePosMin Fin Pour
vecteur pour le mettre en second, etc... Fin PrePosMin
Procedure Permut (var A,B : entier)
Résultat: Permuter le contenu de A et B Procedure permut (var A,B : entier)
A,B: aux  A Résultat: Permuter le contenu de A et B
AB A,B: aux  A
B  aux AB
Fin Permut B  aux
Fin permut
NB: l'appel au niveau de programme principal se fait comme suit:
Proc Tri_Selection_Rec(T,1,N)

Prof. Jamel TALBI Lycée Mourouj 6 Page 1 sur 4


Chapitre3: les algorithmes de tri ~ Résumé des algorithmes de tri 4ème Sciences de l’informatique
Tri à Bulles
Principe Version itérative Version récursive
Procedure Tri_Bulles(var T :tab ; N:entier) Procédure Tri_Bulles_Rec(var T:tab ; N:entier)
Résultat: T_Trié Résultat: Tri_Bulles_Rec
T: Répéter Si N > 1 Alors
Le principe de tri à bulle consiste à : echange  faux pour i de 1 à N-1 faire
 Parcourir le tableau en comparant deux à Pour i de 1 à N-1 faire si T[i] > T[i+1] alors
deux les éléments successifs, permuter si T[i] > T[i+1] alors Proc Permut(T[i], T[i+1])
s'ils ne sont pas dans l’ordre. echange  vrai fin Si
 Répéter tant que des permutations sont Proc Permut(T[i], T[i+1]) Fin Pour
effectuées. fin Si Proc Tri_Bulles_Rec(T, N-1)
Fin Pour Fin Si
jusqu’à Echange = faux Fin Tri_Bulles_Rec
Fin Tri_Bulles NB: l'appel au niveau de programme principal se fait comme suit:
Proc Tri_Bulles_Rec(T,N)

Tri par insertion


Principe Version itérative Version récursive
Procedure Tri_Insertion (var T:tab ; N:entier) Procedure Tri_Insertion_Rec (var vT:tab, i,N : entier)
Le principe consiste à chercher la position de Résultat: T_trié Résultat: Tri_Insertion_Rec
ème T: Pour i de 2 à N faire Si (i <= N) alors
l’i élément dans la partie du tableau
aux  T[i] aux T[i]
commençant de 1 à i sachant que les i-1 premiers ji ji
éléments sont triés. proc decaler(T,j,aux) proc decaler(T,j,aux)
Si cette position est i, l’élément est donc à sa T[j]  aux T[j]  aux
Fin pour Proc Tri_Insertion_Rec(T, i+1, N)
bonne place, sinon, supposons que cette position
Fin Tri_Insertion Fin Si
est j. Ce j est forcément entre 1 et i-1. On décale Procedure decaler(var T :tab ; var j :entier ; aux :entier) Fin Tri_Insertion_Rec
d’un pas vers l’avant (à droite) tous les éléments Résultat : T_décalé
de j à i-1 puis on insère l’élément d’indice i à la T_decalé : Tant que (j >1) ET (T[j-1] > aux) Faire NB: l'appel au niveau de programme principal se fait comme suit:
T[j]  T[j - 1] Proc Tri_Insertion_Rec(T,2,N)
position j.
jj-1
Fin Tant que
Fin decaler

Prof. Jamel TALBI Lycée Mourouj 6 Page 2 sur 4


Chapitre3: les algorithmes de tri ~ Résumé des algorithmes de tri 4ème Sciences de l’informatique

Tri Shell

Principe Version itérative Version récursive


Procédure Tri_Shell (var T:tab, N: entier) Procédure Tri_Shell_Rec(var T :tab ; N,p: entier)
Résultat: T_trié Résultat: Tri_Shell_Rec
T:[p0] Tant que ( p< N) Faire Si (p>0) alors
p 3 * p + 1 Pour i de p+1 à nb Faire
Le principe est le suivant: Fin Tant que aux v[i]
Tant que (p > 0) Faire ji
Les éléments qui ne sont pas à leurs places,
pp div 3 proc decaler(T,j,aux,p)
ne sont pas décalés de 1 à chaque fois, mais Pour i de p+1 à N Faire T[j]  aux
décalés d'un certain nombre de "cases". Le aux  v[i] Fin Pour
nombre de case de décalage est appelé le ji Proc Tri_Shell_Rec (T,N,p div 3)
proc decaler(T,j,aux,p) Fin Si
"pas".
T[j]  aux Fin Tri_Shell_Rec
Une fois qu'on a parcouru la liste, on Fin Pour
Fin Tant Que Fonction Pas(N:entier):entier
recommence en réduisant la taille du pas
Fin Tri_Shell Résultat: Pasp
jusqu'à ce qu'il devienne 1. p:[p0] Tant que ( p< N) Faire
Quand le pas vaut 1, le tri est le même qu'un Procedure decaler(var T :tab ; var j :entier ; p 3 * p + 1
tri par insertion mais la liste est déjà presque aux,p :entier) Fin Tant que
Résultat : T_décalé Fin Pas
triée grâce aux étapes précédentes.
T_decalé : Tant que (j >p) ET (T[j-p] > aux) Faire NB: l'appel au niveau de programme principal se fait comme
T[j]  T[j - p] suit:
j  j -p PFN Pas(N) div 3
Fin Tant que Proc Tri_Shell_Rec(T,N,p)
Fin decaler

Prof. Jamel TALBI Lycée Mourouj 6 Page 3 sur 4


Chapitre3: les algorithmes de tri ~ Résumé des algorithmes de tri 4ème Sciences de l’informatique
Tri par fusion
Principe méthode récursive

Procedure Tri_Fusion( var T :tab ; d,f :entier)


Résultat : T_trié
Si (d<f) alors
m(d+f) div 2
Proc Tri_Fusion(T,d,m)
Proc Tri_Fusion(T,m+1,f)
Proc Fusionner(T,d,m,f)
Fin SI
Fin Tri_Fusion
Le tri par fusion utilise le principe « Diviser pour régner ».
On dit que trier un tableau de taille N, c'est trier deux tableaux de Procedure Fusionner(var T :tab ; d,m,f :entier)
taille N/2. Résultat : T_Trié
Une fois les deux tableaux sont trié , on a plus qu'à les réunir (les T : [id, jm+1]
fusionner) de sorte à ce que le tableau final soit trié. Pour k de d à f faire
Ce tri utilise bien sur la notion de récursivité (un tableau étant la Si(j>f) ou ((i<=m) et( T[i]<T[j])) alors
somme de deux tableaux) Taux[k]T[i]
Ii+1
Sinon
Taux[k]T[j]
Jj+1
Fin si
Fin pour
Pour c de d à f faire
T[c]Taux[c]
Fin pour
Fin Fusionner
NB: l'appel au niveau de programme principal se fait comme suit:
Proc Tri_Fusion(T,1,N)

Prof. Jamel TALBI Lycée Mourouj 6 Page 4 sur 4

Vous aimerez peut-être aussi