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 ; trie : booléen début
trié← faux ;
tant que trie= faux faire // itération sur les passages
trie← vrai ;
Exemple :
Trier par ordre croissant le tableau suivant : 1 5 3 2 7
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 finpour finTQ FIN
Améliorer l’algorithme donné.
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
Pour i de 1 à n-1 faire jmin ←i
Pour j de i+1 à n faire Si T[j] < T[jmin] alors jmin ← j;
FinSi FinPour
Echanger(T[i], T[jmin]) FinPour
Fin
Exemple :
Trier par ordre croissant le tableau suivant : 1 5 3 2 7
Ecrire la procedure echanger (T[i], T[jmin])
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];
j ← i;
tantque ((j > 1) et (tab[j-1] > val)) faire tab[j] ←tab[j-1];
j ←j-1;
fintantque tab[j]← val;
finpour fin
Exemple :
Trier par ordre croissant le tableau suivant : 1 5 3 2 7
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 ;
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];
Exemple :trier le tableau suivant :
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
fin ; 70 17 2 201 415 45 45 102
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
