INF 1131 - Algorithmique et

Structures de données

Licence 2 – Semestre 3
Département informatique
UFR des Sciences et technologies
Université de Thiès
1
 Objectif du cours

➢Ce cours fait suite aux cours d’algorithmique et programmation 1 et 2.

Comme le précédent.
➢Ce cours se veut aussi bien une continuation de l’apprentissage de
l’algorithmique et de la programmation, qu’une poursuite de l’étude du
langage C.
➢Apprendre à implémenté les structures de données

2
 Objectif du cours
➢Résoudre des problèmes en programmant efficacement des structures de
données utiles

➢Etudier et Manipuler des structures de données de base :

• Structures linéaires (piles, files, listes) ;
• Structures arborescentes (arbres binaires, arbres binaires de recherche, tas, arbres équilibrés) ;

➢Applications

➢Langage de programmation utilisé : C

3
PRÉSENTATION DU COURS

4
Présentation générale

• Unité d’Enseignement
• Titre : INFORMATIQUE
• Sigle : INF 233
• Élément constitutif
• Titre : Algorithmique et Structures de données
• Sigle : INF 2331
• Autres éléments constitutifs de l’UE (1)
• Titre Développement web 1
• Sigle : INF 2332

5
Volume horaire & Notation

• CM : 20H (jeudi 09H-12H)

• TD/TP : 20H
• TPE : 40H
• Coefficient de l’UE : 3
• Crédits de l’UE : 8
• Evaluation
• Contrôle des connaissances : 40%
• Examen écrit : 60%

6
 Responsables
• Magistral
Dr François KALY
Maître de conférences assimilé en Informatique
Intelligence Artificielle
Email : [email protected]

• Travaux dirigés et pratiques

M. Abdoulaye DIALLO
Ingénieur en Informatique, Doctorant à l’ ED2S
Email : [email protected]

7
 Plan

➢La récursivité
➢Introduction à la complexité des algorithmes
➢Algorithmes de tri
➢Notion de Types Abstraits de Données
➢Structures linéaires :
• Listes chainées, Piles, Files,
➢Structures arborescentes :
• Arbres Binaires, de Recherche, Arbres équilibrés

8
Introduction à la complexité
des algorithmes

9
 Introduction à la complexité
Introduction
➢Pour un problème donné, il peut exister plusieurs algorithmes pour le
résoudre.
➢Par exemple :
• Problème de tri, algorithmes possibles (tri par sélection, tri par insertion, tri à
bulles, tri rapide, tri par fusion, …)
• Problème de recherche, algorithmes possibles (recherche séquentielle, recherche
dichotomique, …)

➢Il faut donc une analyse de la complexité des algorithmes !

10
 Introduction à la complexité
Analyse de Complexité Algorithmique

➢Consiste à évaluer les ressources nécessaires à l’exécution d’un algorithme

➢Analyse de Complexité Algorithmique:
• le temps d’exécution
• la place mémoire
➢Le but est de choisir (dans des conditions de réalisation égales)
l’algorithme, le mieux adapté et le plus efficace (le moins coûteux) pour
résoudre un problème.
➢On s’intéresse à l’évaluation du temps d’exécution d’un algorithme : la
complexité temporelle

11
 Introduction à la complexité
Comment Evaluer ?

➢ De façon expérimentale:
• on programme l’algorithme
• on exécute le programme sur des ensembles de données variés
• on mesure le temps d’exécution
➢Ceci dépend de plusieurs facteurs :
• la machine utilisée
• le langage de programmation
• le compilateur
• les données
• …
➢ On veut pouvoir dire :
• Sur toute machine, quel que soit le langage de programmation, l’algorithme A1 est meilleur
que l’algorithme A2 pour les données de grande taille
12
 Introduction à la complexité
Comment Evaluer ?

➢De façon formelle (théorique) : on compte le nombre d’opérations

caractéristiques de l’algorithme

➢On se base sur un modèle de machine abstraite sur laquelle l’algorithme

sera implémenté (sous forme de programme)

➢On prendra comme référence un modèle de machine à accès aléatoire (RAM),

munie d’une mémoire et d’un processeur unique, où les instructions sont
exécutées l’une après l’autre, sans opérations simultanées

13
 Introduction à la complexité
Notion de Taille de Données

➢Le temps d’exécution d’un algorithme doit être défini comme une
fonction de la taille des données

➢Exemples :
• le nombre d’éléments à trier,
• le nombre de chiffres dans l’écriture des nombres à multiplier,
• la dimension des matrices à multiplier,
• …

14
 Introduction à la complexité
Représentation du Temps d’Exécution

➢Le temps d’exécution (ou complexité algorithmique) désigne le nombre

d’opérations élémentaires effectuées par un algorithme

➢Il s’exprime en fonction de la taille n des données. On note : T(n)

➢T(n) donne une évaluation du nombre d’opérations élémentaires à

exécuter pour des données de taille n

15
 Introduction à la complexité
Notion d’Opération Elémentaire

➢Une opération est élémentaire lorsque son temps d’exécution est

constant, c’est-à-dire ne dépend pas de la taille des données

➢Exemples :
• Les opérations suivantes sont élémentaires : Appel et retour d’une fonction, Effectuer
une opération arithmétique, Comparer deux nombres , etc.
• Le test d’appartenance d’un élément à un ensemble n’est pas une opération élémentaire parce
que son temps d’exécution dépend de la taille de l’ensemble

16
 Introduction à la complexité
Différentes Complexités

➢Dans la pratique, le temps d’exécution d’un algorithme dépend non

seulement de la taille des données, mais aussi de leurs valeurs précises

➢Exemple :
• Pour la recherche séquentielle d’un élément dans une liste de n éléments,
le temps d’exécution varie selon que l’élément se trouve en première
position, ou que l’élément n’est pas présent dans la liste

• Pour le tri d’une liste, le temps d’exécution varie selon que la liste est
déjà triée ou non

17
 Introduction à la complexité
Différentes Complexités

➢Complexité dans le pire cas (Tmax (n)) : temps d’exécution maximal

d’un algorithme pour des données de taille n

➢Complexité moyenne (Tmoy(n)) : temps moyen d’exécution d’un

algorithme sur tous les jeux de données de taille n

➢Complexité dans le meilleur cas (Tmin(n)) : temps d’exécution

minimal d’un algorithme pour des données de taille n

18
 Introduction à la complexité
Complexité dans le Pire Cas

➢Donne idée de borne supérieure du temps d’exécution pour une entrée quelconque

➢De nombreux algorithmes fonctionnent assez souvent dans le pire cas. Par exemple, la
recherche d’une information dans une base de données

➢Le pire cas est d’importance cruciale pour certaines applications (par exemple, contrôle
aérien, chirurgie, gestion de réseaux)

➢Le meilleur cas apporte peu d’informations car beaucoup d’algorithmes font exactement
la même chose dans une telle situation
➢La complexité en moyenne est en général plus difficile à calculer, car il faut que soit
précisée une distribution de probabilité pour les données de taille n
19
 Introduction à la complexité
Règles de Calcul de Complexité

➢Les opérations élémentaires ont un temps d’exécution constant

➢La complexité d’une séquence d’instructions est la somme des complexités des
instructions qui la composent
➢La complexité d’une instruction conditionnelle est égale à la somme de la complexité
du test et du maximum des complexités des deux alternatives
➢La complexité d’une instruction répétitive est la somme sur toutes les répétitions, de
la somme de la complexité du corps de la boucle et de la complexité de la condition
de boucle
➢La complexité d’une fonction est déterminée par celle de son corps :
• pour une fonction récursive, elle est exprimée comme une équation derécurrence ;
• pour une fonction itérative, elle se calcule en sachant que l’appel à une fonction prend un
temps constant.
20
 Introduction à la complexité
Exemple

• Temps d’exécution de la fonction factorielle

• L’algorithme suivant calcule : n! = n*(n-1)*(n-2)*…*1 avec 0! =1

Temps de calcul = 1+1+(2+2+1)*(n-1)+1= 5n-2 opérations

21
 Introduction à la complexité
Exemple

/* Recherche du maximum d’un tableau d’entiers */

Algorithme MaxTab(T: entier[]; n: entier) : entier Nombre

entrées : un tableau T de n >= 1 entiers d’opérations

sortie : l’élément maximum de T élémentaires

(pire cas)
Début
variables locales : i, max: entier
max  T[0]; // 1
pour i de 1 à n-1 faire // 2
si (T[i]>max) alors // 3
max  T[i] ; // 4
finsi // 5
finpour // 6
retourner max ; // 7 1
Fin 22
 Introduction à la complexité
Notation O (grand O)

➢On s’intéresse à une "estimation asymptotique " (i.e. pour n grand) du temps
d’exécution des algorithmes

➢On évalue l’efficacité d’un algorithme en donnant un "ordre de grandeur" du nombre

d’opérations T(n) qu’il effectue lorsque la taille n du problème qu’il résout augmente

➢On ne calcule ni le temps réel d’exécution sur une machine précise, ni le nombre
exact d’instructions exécutées

➢Pour exprimer cet ordre de grandeur, on utilise les notations de Landau. La plus
fréquente, la notation O (grand O) introduite par la suite, donne une majoration de
l’ordre de grandeur

23
 Introduction à la complexité
Complexité Asymptotique

➢Soient T(n) et f(n), deux fonctions réelles positives du paramètre entier n

➢On dit que T(n) est en O(f(n)) (en grand O de f(n) ) si et seulement si il existe
un entier n0 et une constante c > 0 tels que : T(n) ≤ c f(n), pour tout n ≥ n0

➢On dit aussi que T(n) est de l’ordre de f(n). Par abus de notation, on écrit :
T(n) = O(f(n))

➢Soit maintenant A un algorithme de temps d’exécution T(n).

• On dira que A est de complexité O(f(n))

24
 Introduction à la complexité
Notation O (grand O) : Exemple

➢ T(n) =3n+6 alors T(n) = O(n)

• Démonstration : Pour n>=2; on a 3n+6<=9n ; la quantité 3n+6 est donc bornée à partie d’un certain rang par le produit de n et
d’une constante

➢ T(n) = (n+1) 2 est en O(n)2 .

• Pour le démontrer, prendre n0 = 1 et c = 4

➢ T(n)=3(n)3 +2 (n) 2 est en O(n) 3 .

➢ Pour le démontrer, prendre n0 = 0 et c = 5

• Si T(n) est le temps d’exécution d'un algorithme A, A est donc O(𝑛3 ). On pourrait aussi dire que A est
O(n4), mais, ce serait un énoncé plus faible

➢ T(n) = 3𝑛 n’est pas en O(2𝑛 )

25
 Introduction à la complexité
Notation O (grand O)

26
 Introduction à la complexité
Grandes Classes de Complexité

Grand O Complexité Exemples d’algorithmes

Renvoi du premier élément d’une liste
O(1)
Constante de longueur n
Recherche dichotomique dans un
O(log(n))
Logarithmique tableau trié de taille n
Recherche séquentielle dans un tableau
O(n)
Linéaire de taille n
Tri rapide, tri par tas d’une liste de
O(n log(n))
n log n longueur n
O(𝑛2 ) Quadratique Tris « naïfs » d’une liste de longueur n
Multiplication de deux matrices carrées
O(𝑛3 )
Cubique d’ordre n
O(2𝑛 ) Exponentielle Tours de Hanoi avec n disques 27
 Introduction à la complexité
Grandes Classes de Complexité

28
 Introduction à la complexité
Exemple : 1

➢Boucles simples
• for (i=0; i<n; i++)
{
s;
}
où s est en O(1)
• la complexité en temps est en O(n)
➢Boucles imbriquées
• for(i=0; i<n; i++)
for (j=0; j<n; j++)
{
s;
}
• la complexité est en O(𝑛2 )
29
 Introduction à la complexité
Exemple : 2

➢Boucles logarithmiques
• wh1ile(i<=n)
{
s ;
i= 2 * i;
}
• i prend les valeurs 1, 2, 4, …, jusqu’à ce qu’elle dépasse n
• il y a 1+ log2n itérations
• la complexité est en O(logn)
➢L’indice de la boucle interne dépend de l’indice de la boucle externe
• for (j=0; j<n; j++)
fors(k=0; k<j; k++)
s;
• la boucle interne s’exécute : 1, 2, 3, …., n fois. En sommant sur j,
pour j allant de 1 à n, on a : n (n+1)/2
• la complexité est en O(n2) 30
 Introduction à la complexité
Exemple : 2

31
 Introduction à la complexité
Application de calcul de complexité : multiplication de deux matrices

➢Ecrire un algorithme qui permet de calculer le produit C de deux matrices carré A

et B de dimension (nxn) ensuite de déterminer sa complexité?
➢Principe:

➢L’équation C=A *B s’écrit:

➢En développant cette équation, nous obtenons :

32
 Introduction à la complexité
Multiplication de deux matrices

➢L'algorithme traduit en C :
void multiplier(int A[][p], int B[][m], int C[][m],int n, int m, int p)
{
for (i = 0; i<n; i++) // 1
for (j=0; j<m; j++) // 2
{
S = 0; // 3
for (k =0; k<p; k++) // 4
S = S + A[i][k]*B[k][j]; // 5
C[i][j] = S; // 6
}
}

➢Après analyse, la complexité de l’algorithme est en O(n m p)

33
 Introduction à la complexité
Recherche Séquentielle dans un Tableau de n entiers

➢L'algorithme traduit en C :

int recherche_sequentielle(int *tab, int n, int val)

{
int i; // 1
i = 0; // 2
while ((i<n) && (tab[i] != val)) // 3
i ++; // 4
if (i == n) // 5
return(-1); // 6
else
return(i); // 7
}

➢données. Après analyse, la complexité est :

• en O(1) dans le meilleur cas (val en première position dans le tableau) ;
• en O(n) dans le pire cas (val n’est pas dans le tableau) 34
Les Algorithmes de tri : Trier un tableau

35
 Les Algorithme de tri
Introduction

➢Réaliser un tri (ou un classement) est une opération relativement courante dans
la vie quotidienne :

• trier les cartes d'un jeu,

• trier par ordre alphabétique les livres d'une bibliothèque,
• Classer des concurrents selon leurs performances,
• etc...

➢Un tri porte généralement sur un nombre assez important de données.

➢Effectuer un tri est souvent assez long et fastidieux (du moins quand les données
initiales ne sont pas ou peu triées).
➢Cependant, l'intérêt d'une telle opération, une fois réalisée, est de pouvoir
facilement accéder aux différentes données en s'appuyant sur le critère du tri.
36
 Les Algorithme de tri
Introduction

➢Un tri est toujours réalisé selon un critère, particulier et arbitraire, portant
sur ces données :
➢Ainsi, on peut arbitrairement choisir de classer les livres d'une
bibliothèque selon un ordre croissant ou décroissant :

• alphabétique par auteurs ou par titres ;

• ou numérique selon les dates de parutions, etc.

➢Du fait de leur fréquente utilisation, les tris ont été très étudiés en
informatique et constituent des exercices classiques lors de l'initiation à la
programmation, car ils représentent un excellent support pour l'étude de
problèmes plus généraux
37
 Les Algorithme de tri
Introduction
➢De nombreux algorithmes de tri existent, plus ou moins efficaces et plus ou
moins faciles à mettre en œuvre.
➢Il existe plusieurs types de tri , dans ce cours nous allons examiner les
algorithmes suivant:

• tri par sélection

• tri a bulle
• tri par permutation
• tri par insertion
• tri par fusion
• tri rapide

38
 Les Algorithme de tri
Introduction

➢Soit par exemple un tableau d'entiers de taille N , int T[N] , ce tableau

contient des valeurs entiers non triée . Pour le Trier on peut utiliser un
de ces algorithmes ( on suppose qu'on veut trier le tableau par ordre
croissant )
➢ces tris sont générales , ils sont applicables pour des tableaux de
n'importe quel type , dans ce cours, on se limite au tableau d'entier
juste pour simplifier.

39
 Les Algorithme de tri
Tri par sélection
➢Le principe de l'algorithme de tri par sélection consiste a trouver le
minimum du tableau et le positionner a la première case , une fois cette
opération est faite , on la refait pour le reste du tableau en positionnant le
nouveau minimum a la deuxième case etc ...
• On sélectionne à chaque étape le plus petit élément de la partie non triée
• et en l'échangeant avec l'élément du début de la tranche non triée.

40
 Les Algorithme de tri
Tri par sélection
• Réalisation du tri à l’aide de deux boucles pour en pseudo code
TriParSelection(T:Tableau d’entiers, N:entier)
variables i,j,c,min: entiers
Pour(i← 0 à <N-1) faire
min=i;
pour(j ← i+1 à N) faire
si (T[min]> T[j])
min=j
fin si
Fin pour

c ← T[i];
T[i] ← T[min];
T[min] ← c;
Fin pour
41
 Les Algorithme de tri
Tri par sélection
• On peut réaliser ce tri par 2 boucles for de la manière suivante :
void tri_selection(int *tab, int N)
{
int i,j,tmp,min;
for(i=0;i<N;i++)
{
min = i;
for(j=i+1;j<N; j++){
if (tab[min] > tab[j])
min = j;
}
tmp = tab[i];
tab[i] = tab[min];
tab[min] = tmp;
}
} 42
 Les Algorithme de tri
Tri par sélection

➢Analyse de Complexité

➢A chaque itération, n-i-1 comparaisons et un échange

➢Au total :
• (n-1)+(n-2)+…+2+1 = n (n-1)/2 comparaisons
• n-1 échanges

➢La complexité de l’algorithme est en O(𝑛2 ), dans le meilleur des cas, en

moyenne et dans le pire des cas

43
 Les Algorithme de tri
Tri à bulle
➢C’est un algorithme qui consiste à parcourir le tableau en comparant
2 cases successives , lorsqu'il trouve qu'elles ne sont pas dans l'ordre
souhaité, il permute ces 2 cases .
➢a la fin d'un parcours complet on aura le déplacement du minimum a
la fin du tableau .
➢en faisant cet opération N fois , le tableau serait donc trié .

44
 Les Algorithme de tri
Tri à bulle
• On peut réaliser ce tri par 2 boucles for de la manière suivante :
Tri_bulle(T:Tableau d’entiers, N:entier)
variables i,j,c: entiers;
Pour(j← 1 à N) faire // pour faire l’opération N fois
Pour(i← 1 à N) faire
si( T[i] > T[i+1] ) alors
{
c = T[i];
T[i] = T[i+1];
T[i+1] = c;
}

45
 Les Algorithme de tri
Tri à bulle
• On peut réaliser ce tri par 2 boucles for de la manière suivante :
void Tri_bulle(int *T, int N)
{
int i,j,c;
for(j=1;j<=N;j++) // pour faire l’opération N fois
for(i=0;i<N-1;i++)
if ( T[i] > T[i+1] )
{
c = T[i];
T[i] = T[i+1];
T[i+1] = c;
}
}

46
 Les Algorithme de tri
Tri à bulle

➢Analyse de Complexité

➢Le nombre de comparaisons du tri à bulles = n(n-1)/2

➢Le nombre d'échanges dépend de l'ordre des éléments dans le tableau :
• dans le meilleur des cas, aucun échange
• en moyenne, on montre que : nombre d'échanges = n(n-1)/4
• dans le pire des cas, nombre d’échanges = n(n-1)/2

➢La complexité du tri à bulles est en O(𝑛2 )

47
 Les Algorithme de tri
Tri par permutation
➢cet algorithme consiste a parcourir le tableau jusqu’à ce qu'il trouve
un élément inférieur que le précédent ( mal placé ) ,
➢il prend cet élément et il le rang a sa place dans le tableau , et il
continue le parcours jusqu’à la fin .
➢et affin de ne pas écraser les valeurs du tableau il faut réaliser une
translation des valeurs a l'aide d'une boucle .

48
 Les Algorithme de tri
Tri par permutation
• On peut réaliser ce tri de la manière suivante :
int i,j,k,c;

for(i=1;i<N;i++) {
if ( T[i] < T[i-1] ) { // si l’élément est mal placé
j = 0;
while ( T[j] < T[i] )
j++; // boucle sort par j = la nouvelle position de l’élément

c = T[i]; // ces 2 lignes servent a translater les cases en avant pour pouvoir
insérer l’élément a sa nouvelle position
for( k = i-1 ; k >= j ; k-- )
T[k+1] = T[k];
T[j] = c; // l'insertion
}
}
49
 Les Algorithme de tri
Tri par insertion
• Le principe du tri par insertion est de parcourir la liste non triée (a1, a2, ... ,
an) en la décomposant en deux parties une partie déjà triée et une partie
non triée.
• La méthode est identique à celle que l'on utilise pour ranger des cartes
que l'on tient dans sa main : on insère dans le paquet de cartes déjà
rangées une nouvelle carte au bon endroit.
• L'opération de base consiste à prendre l'élément frontière dans la partie
non triée, puis à l'insérer à sa place dans la partie triée (place que l'on
recherchera séquentiellement), puis à déplacer la frontière d'une position
vers la droite. Ces insertions s'effectuent tant qu'il reste un élément à
ranger dans la partie non triée.. L'insertion de l'élément frontière est
effectuée par décalages successifs d'une cellule.

50
 Les Algorithme de tri
Tri par insertion
• Le tri par insertion peut se faire suivant l’algorithme suivant:
tri_insertion(T:Tableau d’entiers, N:entier)
Variable i,j,x: entiers;
debut
pour i ← 1 à N – 1 faire
# mémoriser T[i] dans x
x ← T[i]
# décaler les éléments T[0]..T[i-1]
qui sont plus grands que x, en partant de T[i-1]
j ← i
tant que (j > 0 et T[j - 1] > x) faire
T[j] ← T[j - 1]
j ← j - 1
fin tant que
# placer x dans le "trou" laissé par le décalage
T[j] ← x
Fin pour
fin
51
 Les Algorithme de tri
Tri par insertion
• Le tri par insertion peut se faire suivant le programme C suivant:
Void tri_insertion(int *T, int N)
{
int i,j,x;
for(i=1; i<N; i++)
{
x = T[i] ;
# décaler les éléments T[0]..T[i-1] qui sont plus
grands que x, en partant de T[i-1]
j = i ;
while ((j > 0)&& (T[j - 1] > x))
{
T[j] = T[j - 1];
j = j – 1;
}
# placer x dans le "trou" laissé par le décalage
T[j] = x;
}
52
}
 Les Algorithme de tri
Tri par insertion
➢Analyse de Complexité

• La complexité du tri par insertion est en O(𝑛2 )

53
 Les Algorithme de tri
Tri par fusion
➢Le tri fusion est construit suivant la stratégie "diviser pour régner", en anglais
"divide and conquer".
➢Le principe de base de la stratégie "diviser pour régner" est que pour résoudre un
gros problème, il est souvent plus facile de le diviser en petits problèmes
élémentaires.
➢Une fois chaque petit problème résolu, il n’y a plus qu’à combiner les différentes
solutions pour résoudre le problème global.
➢La méthode "diviser pour régner" est tout à fait applicable au problème de tri :
• plutôt que de trier le tableau complet, il est préférable de trier deux sous tableaux
de taille égale, puis de fusionner les résultats.

54
 Les Algorithme de tri
Tri par fusion
➢Principe

55
 Les Algorithme de tri
Tri par fusion
• Fusion(T : Tableau d’entiers,p: entier, q: entier, r:entier)
Entrées : T(tableau d’entiers), p,q et r (indices du tableau tels que p<q ≤r)
• Sortie : Tableau trié T entre les indices p et r Pré-condition : T[p..q-1] et
T[q..r] sont triés

Début Tant que (i < q) faire

i,j,k : entier; B[k]← T[i];
B : tableau d’entiers i ← i + 1;
i ← p; k ← p; j ← q; k ← k + 1;
Tant que (i < q et j ≤ r) faire Fin Tant Que
Si T[i]< T[j] alors
B[k]← T[i]; Tant que (j ≤ r) faire
i ← i + 1; B[k]← T[j];
Sinon j ← j + 1;
B[k]← T[j]; k ← k + 1;
j ← j + 1; Fin Tant Que
Fin Si
k ← k + 1; pour i ← 1 à r faire
T[i] = B[i];
Fin Tant Que Fin

56
 Les Algorithme de tri
Tri par fusion
TriFusion(T : Tableau d’entiers,p: entier, r:entier)
Entrées : T(tableau d’entiers), p et r (indices du tableau tels que p ≤ r)
Sortie : Tableau trié T entre les indices p et r

Début
Si p < r
q ← (p+r)/2
TriFusion(T,p,q)
TriFusion(T,q+1,r)
Fusion(T,p,q,r)
Fin Si
Fin

57
 Les Algorithme de tri
Tri par fusion

➢Analyse de Complexité

• Complexité de fusionner en O(n)

• Complexité du tri fusion en O(n log(n))

• Le plus efficace pour les tris externes

58
 Les Algorithme de tri
Tri par Rapide
➢L'algorithme du tri rapide (quicksort en anglais) a été inventé en 1961 par le
britannique Tony Hoare.
➢La méthode consiste à placer un élément du tableau (appelé pivot) à sa place
définitive, en permutant tous les éléments de telle sorte que tous ceux qui lui
sont inférieurs soient à sa gauche et que tous ceux qui lui sont supérieurs soient à
sa droite.
➢Cette opération s'appelle le partitionnement.
➢Pour chacun des sous tableaux, on définit un nouveau pivot et on répète
l'opération de partitionnement. Ce processus est répété récursivement, jusqu'à
ce que l'ensemble des éléments soit trié.

59
 Les Algorithme de tri
Tri par Rapide:
int partitionner(int *T, int premier, int dernier)
{
int pivot = T[premier], i = premier-1, j = dernier+1;
int temp;
while (true) {

do void tri_rapide(int T[], int premier, int dernier)

j--; {
while (T[j] > pivot); int pivot;
if(premier < dernier)
do {
i++;
pivot = partitionner(T,premier, dernier);
while(T[i] < pivot);
tri_rapide(T, premier, pivot-1);
if (i < j) { tri_rapide(T, pivot+1, dernier);
temp = T[i]; }
T[i] = T[j]; }
T[j] = temp;
}
else
return j;
}
}
60
 Les Algorithme de tri
Tri par Rapide
➢Analyse de Complexité

• Cas moyen et meilleur cas :

• Complexité du tri rapide en O(n log(n))
• Pire cas :
• Complexité du tri rapide en O(𝑛2 )

61