Université Abdelmalek Essaâdi

Ecole Nationale des Sciences Appliquées

Al Hoceima

Chapitre 4: Étude de la complexité

de quelques algorithmes
Plan
I. Algorithmes de tri « itératifs »
II. Algorithmes « diviser pour régner »
III.D’autres algorithmes

ENSAH Étude de la complexité de quelques algorithmes E.W. DADI – page : 2

I. Algorithmes de tri itératifs
1. Généralités
Problème de tri : étant donné un tableau T non trié, le problème de
tri consiste à utiliser un algorithme de tri pour ranger les valeurs de
tableau T dans un ordre (un sens) donné(croissant/décroissant).
Exemple A={3, 7, 9, 2, 4, 6, 8} le trie de ce tableau dans l’ordre
croissant donne A={1, 2, 3, 4, 6, 7, 8, 9}
Plusieurs situations nécessite le tri à savoir :
établir le classement de certains élèves,
mettre en ordre un dictionnaire,
faire une sortie lisible d'un correcteur d'orthographe,
etc …
Il existe plusieurs algorithme de tri dans la littérature, à savoir : tri
par sélection, tri par insertion, tri rapide, tri fusion…
Dans la suite on va traiter le cas du tri d’un tableau dans l’ordre
croissant.

ENSAH Étude de la complexité de quelques algorithmes E.W. DADI – page : 3

2. Tri par sélection
L’idée de cette algorithme est basée sur un autre algorithme;
celui qui permet de trouver la valeur minimale ou maximale
d’un tableau. On peut choisir d’utiliser l’un des deux
algorithme (min ou max), si l’algorithme choisit est min, le tri
commence par le début de tableau le contraire est vrai.
À chaque itération de l’algorithme tri par sélection, les étapes
à suivre sont :
Chercher le minimum (resp. maximum) du la partie de
tableau non encore trié.
Échanger le minimum (resp. maximum) avec le premier
(resp. dernier) élément de la partie du tableau non encore
trié.

ENSAH Étude de la complexité de quelques algorithmes E.W. DADI – page : 4

…. la suite
Algorithme de tri par sélection (le cas d’utiliser l’algorithme
min_tableau)
Fonction Tri_sélection(T : Liste, n : Entier)
Var i, imin : Entier;
Début
Pour i : = 1 à n-1 Faire
imin := Obtenir_min(T, i, n);
Si(imin ≠ i) Alors Échanger(T, i, imin) FinSi
FinPour
Fin

Source :wikipedia.org

ENSAH Étude de la complexité de quelques algorithmes E.W. DADI – page : 5

…. la suite
Fonction Obtenir_min(A : Liste, d, f : Entier) : Entier
Var i, j : Entier;
Début
j := d;
Pour i : = d + 1 à f Faire
Si(A[i] < A[j]) Alors j := i; FinSi
FinPour
Retourner(j);
Fin
Fonction Echanger(A : Liste, i, j : Entier)
Var t : Entier;
Début
t := A[i];
A[i] := A[j];
A[j] := t;
Fin

ENSAH Étude de la complexité de quelques algorithmes E.W. DADI – page : 6

…. la suite
Exemple:

51 2 3 4 5
5 9 7 3 8

i=1 3 9 7 5 8 imin= 4, changement

i=2 3 5 7 9 8 imin= 4, changement

i=3 3 5 7 9 8 imin= 3, pas de changement

i=4 3 5 7 8 9 imin= 4, changement

ENSAH Étude de la complexité de quelques algorithmes E.W. DADI – page : 7

…. la suite
Etude de la complexité de l’algorithme Tri_sélection :
La complexité de l’algorithme tri_selection = (n-1)*(complexité
de Obtenir_min + complexité de Echanger)
La complexité de l’algorithme Obtenir_min est linéaire; il dépend
directement de la taille de l’entrée. Si on considère la taille de
l’entrée est k alors C(k)=k.
La complexité de la fonction Echanger est constante.
D’où C(n) = (n+c)+((n-1)+c)+ …+(2+c)
= n+(n-1)+…+2+n*c
= n*c+ n*(n-1)/2
= n(c+(n-1)/2)
= n((n-1+2c)/2) ≤ (1+c) n2
Ce qui implique que C(n)= O(n²).

ENSAH Étude de la complexité de quelques algorithmes E.W. DADI – page : 8

3. Tri à bulles
Idée : le tri à bulles consiste à permuter les éléments adjacents s’ils
ne sont pas ordonnés. À chaque itération i, on parcourt le tableau de
droite à gauche (ou bien de gauche à droite) pour placer le minimum
(ou le maximum) dans la position i par une suite d’échange
d’éléments adjacents.
51 2 3 4 5
5 9 7 3 8

i=1 3 5 9 7 8

i=2 3 5 7 9 8

i=3 3 5 7 8 9

i=4 3 5 7 8 9

ENSAH Étude de la complexité de quelques algorithmes E.W. DADI – page : 9

…. la suite
Algorithme :
Fonction Tri_bulles(T : Tableau, n : Entier)
Var i, j : Entier;
Début
Pour i : = 1 à (n - 1) Faire
Pour j := n à (i + 1) Faire
Si(T[j] < T[j - 1]) Alors Échanger(T, j - 1, j); FinSi
FinPour
FinPour
Fin
Complexité :
Soit C(n) le nombre de comparaisons effectuées par le tri à bulles.
À chaque itération i (de 1 à n-1), on effectue (n - i) comparaisons.
C(n) = (n-1) + … + 1 = ∑i=1,..,n-1(n-i)= (n-1)n/2
C(n) = O(n2).

ENSAH Étude de la complexité de quelques algorithmes E.W. DADI – page : 10

4. Tri par insertion
Idée : À chaque itération de l’algorithme : on prend un élément et
on le compare avec ceux qui lui précèdent puis on décale ceux qui
sont supérieur pour placer l’élément en question à sa place
convenable, comme un joueur tiens des cartes à jouer.
1 2 3 4 5
i=2 5 9 7 3 8 5 9 7 3 8

i=3 5 9 7 3 8 5 7 9 3 8

i=4 5 7 9 3 8 3 5 7 9 8

i=5 3 5 7 9 8 3 5 7 8 9

ENSAH Étude de la complexité de quelques algorithmes E.W. DADI – page : 11

…. la suite
Fonction Tri_insertion(T : Tableau, n : Entier)
Var i, j, clé : Entier;
Début
Pour i : = 2 à n Faire
clé:= T[i]; // sauver T[i]
j := i - 1;
Tant Que((j > 0) et (T[j] > clé)) Faire
T[j + 1] := T[j]; // Décalage
j--;
FinTQ
T[j+1] = clé;
FinPour
Fin

ENSAH Étude de la complexité de quelques algorithmes E.W. DADI – page : 12

…. la suite
Soit C(n) le nombre de comparaisons effectuées par le tri par
insertion.
Dans le pire des cas :
Configuration : un tableau trié dans l’ordre décroissant.
Placer T[i] dans T[1…i-1] nécessite (i-1) comparaisons.
C(n) = 1 + … + (n-1) = ∑i=2,..,n(i-1) = (n-1)n/2
C(n) = O(n2).
Dans le meilleur des cas :
Configuration : un tableau trié dans l’ordre croissant.
Placer T[i] dans T[1…i-1] nécessite 1 comparaison.
C(n) = ∑i=2,..,n(1) = (n-1)
C(n) = Ω(n).

ENSAH Étude de la complexité de quelques algorithmes E.W. DADI – page : 13

5. Tri PRAM
Idée :
Le tableau à trier est placé sur la première ligne d'une grille. Son
transposé (Le même tableau) est aussi placé en colonne. Puis, de 1
jusqu’à n, on compare chaque élément avec les n autres de tableau (les
comparaisons entre chaque couple formé par une valeur ligne et une
valeur colonne). Si la comparaison est vraie on met à l'emplacement
correspondant de la grille, la valeur 1, sinon 0.
Après avoir terminé, on somme les éléments des lignes de la grille
(matrice de 0 et 1) dans un nouveau vecteur. Ces sommes donnent la
position (l’ordre de tri) de chacune des valeurs du tableau à trier.
C’est un algorithme de tri très adapté à la parallélisation. Il permet
de faire le tri de façon très rapide sur des machines multi-cœurs,
Stations multiprocesseurs, Grille de calculs…
NB: cet algorithme fonctionne mieux lorsque tous les éléments d’un
tableau sont différents.

ENSAH Étude de la complexité de quelques algorithmes E.W. DADI – page : 14

…. la suite
Exemple :

≥ 5 9 7 3 8 P
5 1 0 0 1 0 2 On obtient
9 1 1 1 1 1 5 l’ordre de tri

7 1 0 1 1 0 3
3 0 0 0 1 0 1
8 1 0 1 1 1 4

T[ ]= 5 9 7 3 8

P[ ]= 2 5 3 1 4 Tableau trié

i=1, TT[2]=T[1]
i=2, TT[5]=T[2]
TT[P[i]]= T[i] => i=3, TT[3]=T[3] => 3 5 7 8 9
i=4, TT[1]=T[4]
i=5, TT[4]=T[5]

ENSAH Étude de la complexité de quelques algorithmes E.W. DADI – page : 15

…. la suite
Algorithme :
Fonction Tri_PRAM(T : Tableau, n : Entier)
Var i, j : Entier;
Début
Pour i : = 1 à n Faire
S:=1;
Pour j := 1 à n Faire
Si(T[i] > T[j]) Alors S+:=1; FinSi
FinPour
TTrie[S]:=T[i]
FinPour
//T:=TTrie;
Fin
Il est bien clair que la complexité de Tri_PRAM est en O(n²).

ENSAH Étude de la complexité de quelques algorithmes E.W. DADI – page : 16