Algorithmes de tri - UQAC

Algorithmes de tri
1

l’utilité des tris
Problématique:
Un grand nombre de problèmes réels ont recours à la
recherche d’éléments dans un vecteur (tableau). Cette
recherche devient quasiment impossible lorsqu’elle
s’effectue dans un vecteur désordonné, d’où le besoin de
trier les vecteurs avant d’y effectuer un traitement.
Exemples:
• Les mots dans un dictionnaire.
• Fichiers dans un répertoire de PC.
• Les CD répertoriés dans un magasin de musique.
• Les sigles des cours de Poly offert pour une session.
2

Définitions
Tri interne : se dit d'un algorithme qui
n'utilise pas de tableau temporaire pour
effectuer le tri.
Tri externe : se dit d'un algorithme de tri
qui nécessite l'utilisation d'un tableau
temporaire.
3

II – Les tris simples
• Tri par sélection s
• Tri bulle
• Tri par insertion
4

Tri par sélections
Principe :
• Cette technique consiste à parcourir
séquentiellement le vecteur à trier. À l'itération
i, la plus petite valeur du tableau est échangée
avec la valeur située dans la case d'indice i.
5

Exemple d’exd
exécution du tri par
sélection
min = [1] [2]
[3] [4] [0]
i = 0123
10
2
7
15
8
0 1 2 3 4 i
6

Programmation du tri par sélections
template
void TriSelection( vector& Tableau, int n)
{
int i, j, min;
T Tmp;
for ( i=0 ; i

Tri en bulle
Principe :
• Les petits éléments du tableau « remontent »
(comme des bulles) vers le début du tableau pour
atteindre leur position finale. Les plus « légers »
remontent le plus rapidement. Une fois tous les
éléments remontés, le tableau est trié.
8

Exemple d’exd
exécution du tri en bulle
: comparaison de
deux éléments
10
2
7
15
8
Position de i
0 1 2 3 4 i
9

Programmation du tri en bulle
template
void TriBulle(vector& Tableau, , int n)
{
int i,j;
T Tmp;
for ( i=0; ii; j--j
--)
if ( Tableau[j-1]> Tableau[j])
{
Tmp = Tableau[j-1];
Tableau[j-1] = Tableau[j];
Tableau[j] = Tmp;
}
}
10

Tri par insertion
Principe :
• Cette stratégie est semblable à la méthode
qu'utilise naturellement un joueur de cartes pour
organiser sa main. À chaque étape, une partie
du tableau est déjà ordonnée et une nouvelle
valeur est insérée à l'endroit approprié.
11

Exemple d’exd
exécution par insertion
10
2
7
15
8
0 1 2 3 4 i
12

Programmation du tri par insertion
template < class T>
void TriInsertion(vector& Tableau, int n)
{
int i,j;
T Tmp;
for ( i=1;i

Analyse des tris simples
Meilleur cas: tableau déjà trié
1 3 5 7 9 10 13 18 21 25
Cas moyen: tableau aléatoire
7 10 21 9 1 25 18 3 5 13
Pire cas: tableau trié à l’envers
25 21 18 13 10 9 7 5 3 1
14

Comparaison des tris simples
Pire cas Cas moyen Meilleur cas
Tri par sélection
Tri en bulle
Tri par insertion
O ( n
2 ) (
2
O n ) (
2
O n )
O ( n
2 ) (
2
O n ) (
2
O n )
O ( n
2 ) (
2
n )
O O( n)
15

mergesort
Problématique :
Le tri est effectué en utilisant la technique de diviser-etconquérir,
en divisant le problème en deux sousproblèmes
de complexité θ ( n)
résolus récursivement,
offrant une complexité globale de
L'algorithme de tri Mergesort :
( nlog2 n )
1. Si le nombre d’éléments à trier == (0 ou 1), retourner.
2. Trier récursivement la première et deuxième moitié
séparément.
3. Regrouper les deux parties triées dans un nouveau groupe
trié.
θ
16

MergeSort
1 13 24 26 2 15 27 38
Actr
Bctr
Cctr
17

La fonction Mergesort
// Routine interne : Tableau: le vecteur d’éd
’éléments
// tmpTab: vecteur temporaire pour les résultatsr
// left, right: indices gauche et droit des tableaux
template
void mergeSort(vector& Tableau, vector& tmpTab,
int left, int right)
{
if (left < right)
{
int center = (left+right)/2;
mergeSort(Tableau, tmpTab, left, center)
mergeSort(Tableau, tmpTab, center+1, right);
merge(Tableau, tmpTab, left, center+1, right);
}
}
template // Fonction principale
void mergeSort(vector& Tableau)
{
vector tmpTab(Tableau.size());
mergeSort(Tableau,tmpTab,0,Tableau.size()-1);
}
18

La fonction Merge
// Routine interne : Tableau: le vecteur d’éd
’éléments
// tmpTab: vecteur pour les résultats r
du merge
// leftPos: indice gauche du tableau
// rightPos: indice du début d
de la 2ieme demi
// rightEnd: indice droit du tableau
template
void merge(vector& Tableau, vector& tmpTab, int leftPos,
int rightPos, int rightEnd)
{
int leftEnd = rightPos-1;
int tmpPos = leftPos;
int numElements = rightEnd – leftPos +1;
//Boucle principale
while( leftPos

La fonction Merge
. . .
while(leftPos

Le tri rapide (Quicksort(
Quicksort)
Idée e générale g
:
Dans cet algorithme, l'exécution du tri est simplement délégud
guée à une
série d'appels récursifs. r
Une fonction de partitionnement est d'abord
appelée. e. Cette fonction choisit arbitrairement un pivot qui est utilisé
pour subdiviser le tableau en deux parties:
1. une partie de gauche oùo
tous les éléments ont une valeur plus petite
ou égale au pivot;
2. une partie de droite oùo
tous les éléments ont une valeur plus grande
ou égale au pivot.
Par la suite, les deux parties ainsi obtenues sont triées par deux appels
récursifs
à la fonction de tri rapide.
En plus de la fonction principale de tri rapide, une autre fonction est
donc requise: celle qui procède
à la partition du tableau.
21

Quicksort : choix du pivot
premier élément ?
élément aléatoire?
dernier élément?
élément médian?
…. 7 2 9 6 1 5 4 3 …..
22

La fonction Quicksort
template
void QuickSort(vector& tableau, int inf,
int sup)
{
int milieu;
if (sup>inf) // s'il y a au moins 2
éléments
{
milieu = Partition(tableau, inf, sup);
}
}
// trier la partie de gauche
QuickSort(tableau, inf, milieu);
// trier la partie de droite
QuickSort(tableau, milieu+1, sup);
23

Exemple d’exd
exécution de Partition
i
Premier Pivot =
appel
Tab[2] = 5
Quicksort(a,0,4)
j
11
7
5
2
9
0 1 2 3 4 i
24

La fonction Partition
template
int Partition(vector& tableau, int inf, int sup)
{
T pivot, tempo;
int i,j;
pivot = tableau[(sup+inf)/2];
i = inf-1;
j = sup+1;
while ( i

Complexité du Quicksort
Cas moyen et meilleur cas
Complexité du Quicksort dans le cas moyen
et dans le meilleur cas θ( nlog2 n ).
Pire cas
Complexité du Quicksort dans le pire cas:
θ
2
( n )
26