Leçon 3 : Introduction à la complexité des algorithmes

Algorithmes de recherche & Algorithmes de tri

Rodrigue DJEUMEN

Rodrigue DJEUMEN Leçon 3 : Introduction à la complexité des algorithmes 1 / 22

 Sommaire

Sommaire

1 Sommaire

2 Notion de complexité
Dénitions
Ordre de grandeur

3 Algorithme de recherche dans un tableau

Parcours avec traitement sélectif
Recherche séquentielle
Recherche dichotomique

4 Algorithmes de tri
Tri par insertion
Tri par sélection
Tri par échange
Le tri rapide
Principe
Le partitionnement
Permute et acher
Quick sort

Rodrigue DJEUMEN Leçon 3 : Introduction à la complexité des algorithmes 2 / 22

 Notion de complexité Dénitions

Complexité d'un algorithme

Il existe généralement diérentes solutions algorithmiques pour un problème

donné.
Il est donc nécessaire de pouvoir comparer les performances des diérents
algorithmes et choisir le meilleur pour résoudre un problème particulier.
L'analyse des performances d'un algorithme i.e. sa complexité, représente la
quantité de ressources (temps, nombre d'instructions ou espace mémoire)
nécessaire à l'exécution de cet algorithme.
La complexité d'un algorithme consiste à évaluer :
1 Le temps d'exécution ( on parle de complexité temporelle)
2 La quantité mémoire nécessaire (ou complexité spatiale)

Les complexités temporelle et spatiale dépendent de plusieurs éléments comme le

matériel, le système d'exploitation, les processeurs, etc. Cependant, du fait de la
constante évolution technologique, seul le temps d'exécution d'un algorithme est
considéré dans l'analyse.

Rodrigue DJEUMEN Leçon 3 : Introduction à la complexité des algorithmes 3 / 22

 Notion de complexité Dénitions

La complexité est déterminée de manière formelle, suivant diérentes

scenarii :
temps d'exécution dans le pire des cas,
temps d'exécution dans le cas moyen,
temps d'exécution dans le meilleur des cas.
Exemple : Considérons tableau d'entier A de taille N et un entier x ; soit à
déterminer si x est contenu dans A. Une solution simple à ce problème
consiste à parcourir tout le tableau en comparant chaque élément du tableau
avec x .
i = 0;
while(i<N){
if (A[i]== x )
return 1;
i++;
}
return 0;

Rodrigue DJEUMEN Leçon 3 : Introduction à la complexité des algorithmes 4 / 22

 Notion de complexité Dénitions

Analyse de complexité

Opérations élémentaires dans l'algorithme : 1 aectation, 2

comparaisons, 1 incrémentation et 1 return.
Meilleur des cas : si l'élément cherché est le premier

Considérons le pire des cas : i.e. l'élément cherché est le dernier dans le
tableau
1 Par hypothèse, toutes les opérations élémentaires ont le même temps
d'exécution noté t.
1 Temps utilisé pour l'aectation : 1 × t ,
2 Temps de comparaison : égalité (N × t), inférieur (N × t + t),
3 Temps d'incrémentation (N × t),
4 Temps pour l'instruction return : 1 × t .
2 Complexité au pire des cas :
t + (N × t) + (N × t + t) + (N × t) + t = 3(N × t)+3
3 On constate dans ce cas que le temps d'exécution est fonction de la
taille N du tableau.

Rodrigue DJEUMEN Leçon 3 : Introduction à la complexité des algorithmes 5 / 22

 Notion de complexité Ordre de grandeur

Ordre de grandeur

L'ordre de grandeur est la façon dont le temps d'exécution dépend de la taille de

l'entrée.
Dans l'exemple ci-dessus, nous pouvons clairement voir que le temps d'exécution
dépend linéairement de la longueur du tableau.
La complexité en temps est donnée sous la forme d'un ordre de grandeur sur le
temps, tel que résumé par le tableau suivant :
Temps Type de complexité
O(1) Constante
O(log (n)) logarithmique
√
O( n) racinaire
O(n) linéaire
O(n²) quadratique
O(n³) cubique
... ...

L'algorithme précédent a pour ordre de grandeur O(n).

Rodrigue DJEUMEN Leçon 3 : Introduction à la complexité des algorithmes 6 / 22
 Algorithme de recherche dans un tableau Parcours avec traitement sélectif

Traitement sélectif

Principe
Pour un vecteur donné, il s'agit d'une opération de recherche, permettant de ne
traiter que les éléments ayant une valeur particulière, sachant que cette valeur
peut apparaître zéro, une ou plusieurs fois dans le vecteur.

Exemple : Écrire un programme permettant de lire les valeurs d'un tableau

d'entiers et ensuite d'acher les valeurs négatives de ce tableau.
int main(){
int vec[100]; int i;
for (i = 0; i<100; i++)
read(vec[i]);
for (i = 0; i<100; i++)
if (vec[i] < 0) then
write(vec[i]);
}
Exercice 1 : Montrer que la complexité au pire des cas de cet algorithme est de
l'ordre O(n).
Rodrigue DJEUMEN Leçon 3 : Introduction à la complexité des algorithmes 7 / 22
 Algorithme de recherche dans un tableau Recherche séquentielle

Recherche séquentielle

Principe
Cette opération de recherche suppose que l'élément cherché apparaît au plus une
et une seule fois dans le vecteur. Le parcours s'arrêtera dans deux cas :
Soit dès que l'on aura trouvé l'élément cherché,
Soit, lorsque l'on aura rencontré le dernier élément.
Exemple : Supposons que l'on dispose d'un vecteur vec contenant les
enregistrements d'informations sur les étudiants. Un étudiant est caractérisé par
son matricule , son nom et son pr énom ; écrire un programme permettant
d'acher les informations d'un étudiant de matricule mat donné, lu au clavier.
#define N 100;
typedef struct{
char matricule[6];
char nom[40];
char prenom[40];
}Etudiant;

Rodrigue DJEUMEN Leçon 3 : Introduction à la complexité des algorithmes 8 / 22

 Algorithme de recherche dans un tableau Recherche séquentielle

int main(){
Etudiant vec[N]; char mat[6];
int i, TROUVE;
printf(Entrez le matricule de l'étudiant cherché);
mat = gets();
TROUVE = false;
i = 1;
while ((i <= N) && (!TROUVE)){
if (vec[i].matricule == mat){
puts(vec[i].matricule);
puts(vec[i].nom);
puts(vec[i].prénom);
TROUVE = vrai;
}
i++;
}
}
Exercice 2 : Montrer que la complexité au pire des cas de cet algorithme est de
l'ordre O(n).

Rodrigue DJEUMEN Leçon 3 : Introduction à la complexité des algorithmes 9 / 22

 Algorithme de recherche dans un tableau Recherche dichotomique

Recherche dichotomique

Considérons un tableau d'éléments trié (ordre croissant ou décroissant)

Soit à chercher 42 dans un tableau

Rodrigue DJEUMEN Leçon 3 : Introduction à la complexité des algorithmes 10 / 22

 Algorithme de recherche dans un tableau Recherche dichotomique

Version itérative

int rechDicho(Vecteur vec, int g, int d, int val){

int m;
while (g <= d) {
int m = (g + d)/2;
if (vec[m] == val) return m;
if (vec[m] < val)
g = m + 1;
else
d = m - 1;
}
return -1;
}

Rodrigue DJEUMEN Leçon 3 : Introduction à la complexité des algorithmes 11 / 22

 Algorithme de recherche dans un tableau Recherche dichotomique

Version récursive

int rechDichoRec(Vecteur vec, int g, int d, int val){

int m;
if(g <= d) {
int m = (g + d)/2;
if (vec[m] == val) return m;
if (vec[m] < val)
return rechDichoRec(vec,m+1,d,val);
else
return rechDichoRec(vec,g,m,val);
}
return -1;
}
Exercice 3 : Montrer que la complexité au pire des cas de cet algorithme est de
l'ordre O(log (n)).

Rodrigue DJEUMEN Leçon 3 : Introduction à la complexité des algorithmes 12 / 22

 Algorithmes de tri Tri par insertion

Tri par insertion

Chaque valeur vec[i] est insérée à la bonne place parmi les valeurs déjà ordonnées du
sous-vecteur vec[1], . . . , vec[i − 1].
Au départ, ce sous-vecteur se réduit à vec[1] et on a i = 2.
Chaque insertion se fait par comparaisons et décalages successifs et a pour conséquence
d'agrandir le sous-vecteur ordonné d'un élément. La dernière insertion est celle de vec[n].

Rodrigue DJEUMEN Leçon 3 : Introduction à la complexité des algorithmes 13 / 22

 Algorithmes de tri Tri par insertion

Exemple : On dispose d'un vecteur vec de n valeurs entières à trier. Appliquer

l'algorithme de tri par insertion pour trier ce vecteur.
void triInsertion(Vecteur vec, int n){
int i, j, aux;
for (i=1 ; i <= n-1; i++) {
j = i;
while (j > 0 && vec[j-1] > vec[j]){
aux = vec[j];
vec[j] = vec[j-1];
vec[j-1] = aux;
j--;
}
}
}
Exercice 4 : Montrer que la complexité au pire des cas de cet algorithme est de
l'ordre O(n2 ).

Rodrigue DJEUMEN Leçon 3 : Introduction à la complexité des algorithmes 14 / 22

 Algorithmes de tri Tri par sélection

Tri par sélection

Principe
On parcourt le vecteur vec pour sélectionner l'élément ayant la plus faible valeur puis, on
échange sa valeur avec celle de V [0]. On procède ensuite de la même manière pour
vec[1], ..., vec{n − 1], puis vec[3], ..., vec[n], etc... jusqu'à vec[n − 2], vec[n − 1].

Rodrigue DJEUMEN Leçon 3 : Introduction à la complexité des algorithmes 15 / 22

 Algorithmes de tri Tri par sélection

void triSelection(Vecteur vec, int n){

int i,j,index,aux;
for (i=0; i < (n-1); i++){
index = i;
for (j=i + 1; j < SIZE; j++){
if (vec[index] > vec[j])
index = j;
}
if (index != i){
aux = vec[i];
vec[i] = vec[index];
vec[index] = aux;
}
}
}
Exercice 5 : Montrer que la complexité au pire des cas de cet algorithme est de
l'ordre O(n2 ).

Rodrigue DJEUMEN Leçon 3 : Introduction à la complexité des algorithmes 16 / 22

 Algorithmes de tri Tri par échange

Tri par échange ou tri bulle

Principe
Les éléments du vecteur sont comparés deux à deux et permutés si
V [k] > V [k + 1]. le premier passage positionne le plus grand élément, le
deuxième positionne le deuxième plus grand, etc...

Rodrigue DJEUMEN Leçon 3 : Introduction à la complexité des algorithmes 17 / 22

 Algorithmes de tri Tri par échange

void triBulle(Vecteur vec, int n){

int i,j,aux;
for (i=0 ; i < n-1; i++){
for (j=0 ; j < n-i-1; j++){
if (vec[j] > vec[j+1]){
aux = vec[j];
vec[j] = vec[j+1];
vec[j+1] = aux;
}
}
}
}
Exercice 6 : Montrer que la complexité au pire des cas de cet algorithme est de
l'ordre O(n2 ).

Rodrigue DJEUMEN Leçon 3 : Introduction à la complexité des algorithmes 18 / 22

 Algorithmes de tri Le tri rapide

Principe du tri rapide (Quick sort)

Rodrigue DJEUMEN Leçon 3 : Introduction à la complexité des algorithmes 19 / 22

 Algorithmes de tri Le tri rapide

Partition d'un tableau

int partition (int t[], int inf, int sup){

int pivot = sup;
int i = inf - 1;
for (int j = inf; j <= sup-1; j++){
if (t[j] <= t[pivot]){
i++;
permuter(t,i,j);
}
}
permute(t,i + 1, pivot);
return (i + 1);
}

Rodrigue DJEUMEN Leçon 3 : Introduction à la complexité des algorithmes 20 / 22

 Algorithmes de tri Le tri rapide

Permuter()

void permuter(int t[],int i,int j){

int x = t[i];
t[i]=t[j];
t[j]=x;
}

Rodrigue DJEUMEN Leçon 3 : Introduction à la complexité des algorithmes 21 / 22

 Algorithmes de tri Le tri rapide

Algorithme récursif du Qsort

Le tri rapide sur un tableau t se décrit récursivement par :

void qsort(int t[],int inf, int sup){
if(inf < sup){
int m = partition(t,inf,sup);
qsort(t,inf,m-1);
qsort(t,m+1,sup);
}
}
Exercice 7 : Montrer que la complexité au pire des cas de cet algorithme est de
l'ordre O(n2 ) et au cas moyen de l'ordre O(n log (n)).

Rodrigue DJEUMEN Leçon 3 : Introduction à la complexité des algorithmes 22 / 22