Chapitre 2

Algorithmes de tri

On désigne par "tri" l’opération consistant à ordonner un ensemble d’éléments en fonc-

tion de clés sur lesquelles est définie une relation d’ordre.
Les algorithmes de tri ont une grande importance pratique. Ils sont fondamentaux dans
pratiquement tous les domaines et c’est rare qu’on voit une application informatique sans
besoin de trier des éléments.
On trouve dans la littérature plusieurs algorithmes de tri qui se diffèrent dans la com-
plexité :

4.1 Méthodes simples

4.1.1 Tri par bulle

On balaye la liste en échangeant deux éléments consécutifs s’ils sont dans le mauvais
ordre. Le plus grand élément de la liste est donc repoussé à la fin.
On recommence à partir du début, avec les n - 1 premiers éléments et ainsi de suite.

01

www.etudpdf.com
 Procédure T riP arBulles( T : tableau[1..n] de entier);
Var i,j,temp : entier ;
Début
Pour i de 1 à n 1 faire
Pour j de 1 à n i faire
Si (T [j] > T [j + 1]) Alors
temp T [j] ;
T [j] T [j + 1] ;
T [j + 1] temp ;
Fin Si;
Fin Pour;
Fin Pour;
Fin;

L’exemple suivant montre une trace de cet algorithme pour trier un tableau de quatre
éléments :

Le nombre d’itérations faite par la procédure en fonction deux n est :

Pn 1 P n i
= (n 1) + (n 2) + ... + (n (n 1)) = n(n 1) n(n 1)/2
n2 n
= n2 n 2 + 2 = 12 n2 1
2n

Donc la complexité de la procédure est de O(n2 ).

4.1.2 Tri par insertion

On suppose que les i-1 premiers éléments de la liste sont déjà classés. On insère à sa
place le ieme élément parmi les i-1 premiers ; de la sorte, les i premiers éléments sont triés.
On itère jusqu’à insérer le neme .

02

www.etudpdf.com
 Procédure T riInsertion( T : tableau[1..n] de entier);
Var i,j,temp : entier ;
Début
Pour i de 2 à n faire
k i-1 ;
temp T [i] ;
Tant que (k 1 et temp < T [k] ) faire
T [k + 1] T [k] ;
k k 1;
Fin TQ;
T [k + 1] temp ;
Fin Pour;
Fin;

La complexité de l’algorithme au pire des cas est O(n2 )

4.1.3 Tri par sélection

Le tri par sélection consiste simplement à sélectionner l’élément le plus petit du tableau
à trier, à le mettre au début, et à répéter itérativement le processus tant qu ?il reste des
éléments dans le tableau.

03

www.etudpdf.com
 Procédure T riP arSelection( T : tableau[1..n] de entier);
Var i,j,IndMin,temp : entier ;
Début
Pour i de 1 à n 1 faire
IndMin i;
Pour j de i+1 à n faire
Si (T [j] < T [IndM in]) Alors
IndMin j;
Fin Si;
Fin Pour;
temp T [i] ;
T [i] T [IndM in] ;
T [IndM in] temp ;
Fin Pour;
Fin;

La figure suivante illustre une trace de cet algorithme :

L’algorithme fait n-1 itérations, à chaque itération i il fait n-i-1 itération d’où sa com-
plexité est O(n2 )

04

www.etudpdf.com
4.2 Tri par fusion

Le tri par fusion (merge sort en anglais) est une illustration du principe "diviser pour
résoudre" : le tableau à trier est tout d ?abord scindé (divisé) en deux suites de longueurs
égales. Ces deux suite sont ensuite triées séparément avant d’être fusionnées (ou interclas-
sées).
Exemple :

Dans cet exemple, le tableau de quatre éléments est scindé en deux tableaux de deux
éléments chacun. Chaque tableau est trié de la même façon que le tableau initial. Après le
tri des deux tableaux, ils sont fusionnés pour donner le tableaux entier trié. La division s’ar-
rête lorsqu’on obtient un tableau d’une seule case qui est naturellement trié. L’algorithme
détaillé est le suivant :

05

www.etudpdf.com
Algorithme TriParFusion;
Var T : tableau[1..n] de entier ;
Procédure F usion( Debut,Fin : entier);
Début
// Vu en TP
Fin;

Procédure T riP arF usion( Debut,Fin : entier);

Début
Si (Debut<Fin) Alors
T riP arF usion(Debut,(Debut+Fin) div 2) ;
T riP arF usion((Debut+Fin) div 2 + 1,Fin) ;
F usion(Debut,Fin) ;
Fin Si;
Fin;

Début
Pour i de 1 à n faire
Lire(T[i]) ;
Fin Pour;

T riP arF usion(1,n) ;

Pour i de 1 à n faire
Ecrire(T[i]) ;
Fin Pour;
Fin.

La complexité de l’algorithme peut être calculée comme suit :

06

www.etudpdf.com
 T(n) = 2T(n/2) + n 1
= 2 [2(T(n/4) + n/2] + n) = 4 T(n/4) + 2n 2
= 4 [2T(n/8) + n/4 ] + 2n = 8T(n/8) + 3n 3
= 8[2T(n/16) + n/8] + 3n 16T(n/16) + 4n 4
:
= 2i T(n/2i ) + in i
:
= n T(1) + log2 (n)n log2 (n)
= n(log2 (n) + 1)

Donc la complexité de l’algorithme est O(nlog2 (n))

4.3 Tri rapide

Le tri rapide (quicksort) consiste à partitionner le tableau T à trier en deux sous-

tableaux T1 et T2 contenant respectivement les plus petits et les plus grands éléments de
T, puis à appliquer récursivement l’algorithme sur les tableaux T1 et T2.
Il existe plusieurs méthodes pour partitionner un tableau. Le principe général consiste
à utiliser un élément particulier, le pivot, comme valeur de partage.
On peut prendre pour le pivot le premier élément du tableau, comme on peut choisir
aléatoirement un élément quelconque du tableau.
Exemple :

07

www.etudpdf.com
 La méthode de tri rapide permet d’éviter l’opération de fusion et ainsi gagner en temps
de calcul.
L’algorithme détaillé est le suivant :

08

www.etudpdf.com
Algorithme TriRapide;
Var T : tableau[1..n] de entier ;
Procédure P artirion( Debut,Fin : entier ; var IPivot : entier);
var Pivot,i,temp : entier ;
Début
Pivot T[Debut] ;
i Debut + 1 ;
Pour j de Debut+1 à Fin faire
Si (T [j]  Pivot) Alors
// Permuter T[i] et T[j]
temp T [i] ;
T [i] T [j] ;
T [j] temp ;
i i + 1;
Fin Si;
Fin Pour;

// Permuter T[Debut] et T[i - 1]

temp T [Debut] ;
T [Debut] T [i 1] ;
T [i 1] temp ;
IPivot i - 1;
Fin;

Procédure T riRapide( Debut,Fin : entier);

var IPivot : entier ;
Début
Si (Debut<Fin) Alors
P artition(Debut,Fin,IPivot) ;
T riRapide(Debut,IPivot-1) ;
T riRapide(IPivot+1,Fin) ;
Fin Si;
Fin;

Début
T riRapide(1,n) ;
Fin.

09

www.etudpdf.com
 Dans le pire des cas le tableau est déjà trié. Dans ce cas la procédure P artition parcourt
le tableau jusqu’à la fin et retourne un pivot au début du tableau. La procédure T riRapide
est relancée alors sur les derniers n-1 éléments. Le temps de calcul peut être donnée par :
T (n) = n + (n 1) + (n 2) + ....(n n) = 12 n2 2
2n

La complexité est alors en O(n2 ).

Dans le cas moyen le pivot se met à chaque fois au milieu du tableau. La procédure
P artition parcours le tableau en O(n) est les deux appels de la procédure T riRapide sont
effectué sur une moitié du tableau chacun. Le temps de calcul peut être trouvé comme
dans le cas du tri par fusion :
T (n) = n + 2T (n/2) et la complexité est alors de O(nlogn).
En pratique, c’est l’algorithme le plus utilisé et très souvent, le plus rapide.

10

www.etudpdf.com
 Chapitre1:Introduction à la complexité algorithmique 2 année licence informatique

Module Algorithmique et Structures de Données 3

(ASDD3)
Deuxième Anneé Licence Informatique

Chapitre 1:
Introduction à la complexité algorithmique

I – Introduction
"Si l’on veut résoudre un problème à l’aide d’un ordinateur, il est indispensable
d’avoirrecours à un algorithme car un ordinateur ne peut exécuter que des ordres
précis et sans ambiguïté."
Stockmeyer et Chandra

Ce chapitre a pour but de présenter à l'étudiant des notions pour lui permettre de
comprendre la complexité algorithmique et comment l’utiliser. Cette notion
est importante car si vous voulez résoudre un problème avec un ordinateur,
comme le disent Stockmeyer et Chandra, il vous faut un algorithme. Or pour
pouvoir l’étudier et le comparer avec d’autres,il faut utiliser la notion de complexité .

ASDD3 1

www.etudpdf.com
 Chapitre1:Introduction à la complexité algorithmique 2 année licence informatique

II – Complexité
Nous allons commencer par définir la complexité d’un algorithme, puis étudier les données
qui lui sont liées, calculer certaines complexités pour pouvoir enfin obtenir un outil de
comparaison.

II.1 – Définitions

Définition 1
Algorithme
Th. H. Cormen, Ch. E. Leiserson, R. L. Rivest, C. Stein , ont donné cette définition :
"Procédure de calcul bien définie qui prend en entrée une valeur, ou un ensemble
devaleurs, et qui donne en sortie une valeur, ou un ensemble de valeurs. Un algorithme
est donc une séquence d’étapes de calcul qui transforment l’entrée en sortie."

Exemple 1
Pour rechercher un nombre dans un tableau trié, le principe de dichotomie consiste à
couper ce tableau en deux, à chercher dans une partie et si ce n’est dans celle-ci, alors
nous cherchons dans l’autre et ainsi de suite jusqu’à la fin. Nous nous arrêtons quand la
valeur a été trouvée ou bien lorsque nous sommes arrivé à la fin du tableau c.a.d. quand
la valeur recherchée n’est pas dans le tableau.
Algorithme de recherche dichotomique

RECHERCHE_DICHOTOMIQUE
Entrée : un tableau de n nombres A=[ a 1 , a 2 , a3 ,... , a n ] trié par ordre croissant
et une valeur v
Sortie : un indice i tel que v =A[i] , ou bien la valeur spéciale NIL si v ne
figure pas dans A
1 début ← 1
2 fin ← n
3 trouvé ← FALSE
4 répéter
5 milieu ← partie entière(début + (fin – début) / 2)
6 si A [ milieu]=v
7 alors trouvé ← TRUE
8 sinon
9 si v A [ milieu ]
10 alors
11 début ← milieu + 1
12 si A[début ]=v
13 alors
14 milieu ← début
15 trouvé ← TRUE
16 fin si

ASDD3 2

www.etudpdf.com
 Chapitre1:Introduction à la complexité algorithmique 2 année licence informatique

17 sinon
18 fin ← milieu – 1
19 si A [ fin]=v
20 alors
21 milieu ← fin
22 trouvé ← TRUE
23 fin si
24 fin si
25 fin si
26 jusqu’à trouvé ou début ≥ fin

Définition 2: F. Grimbert a expliqué que :

"La complexité d’un algorithme est le nombre d’opérations élémentaires qu’il doit effectuer
pour mener à bien un calcul en fonction de la taille des données d’entrée".
Pour Stockmeyer et Chandra, "l’efficacité d’un algorithme est mesurée par l’augmentation du
temps de calcul en fonction du nombre des données."
Nous avons donc deux éléments à prendre en compte :
• la taille des données ;
• le temps de calcul.

II.2 – La taille des données

La taille des données (ou des entrées) va dépendre du codage de ces entrées.
On choisit comme taille la ou les dimensions les plus significatives.
Par exemple, en fonction du problème, les entrées et leur taille peuvent être :
– des éléments : le nombre d’éléments ;
– des nombres : nombre de bits nécessaires à la représentation de ceux-là ;
– des polynômes : le degré, le nombre de coefficients non nuls ;
– des matrices m × n : max(m,n), m.n, m + n ;
– des graphes : nombre de sommets, nombre d’arcs, produit des deux ;
– des listes, tableaux, fichiers : nombre de cases, d’éléments ;
– des mots : leur longueur.

ASDD3 3

www.etudpdf.com
 Chapitre1:Introduction à la complexité algorithmique 2 année licence informatique

II.3 – Le temps de calcul

Le temps de calcul d’un programme dépend de plusieurs éléments :
– la quantité de données bien sûr ;
– mais aussi de leur encodage ;
– de la qualité du code engendré par le compilateur ;
– de la nature et la rapidité des instructions du langage ;
– de la qualité de la programmation ;
– et de l’efficacité de l’algorithme.
Nous ne voulons pas mesurer le temps de calcul par rapport à toutes ces variables.
Maisnous cherchons à calculer la complexité des algorithmes qui ne
dépendra ni del’ordinateur, ni du langage utilisé, ni du programmeur, ni de
l’implémentation. Pour cela,nous allons nous mettre dans le cas où nous
utilisons un ordinateur RAM (Random Access Machine) :
– ordinateur idéalisé ;
– mémoire infinie ;
– accès à la mémoire en temps constant ;
– généralement à processeur unique (pas d’opérations simultanées).
Pour connaître le temps de calcul, nous choisissons une opération fondamentale et
nous calculons le nombre d’opérations fondamentales exécutées par l’algorithme.

II.4 – Opération fondamentale

C’est la nature du problème qui fait que certaines opérations deviennent
plus fondamentales que d’autres dans un algorithme.
Par exemple :

Tableau 1 : opérations fondamentales en fonction des problèmes

ASDD3 4

www.etudpdf.com
 Chapitre1:Introduction à la complexité algorithmique 2 année licence informatique

II.5 – Coût des opérations

II.5.1 – Coût de base

Pour la complexité en temps, il existe plusieurs possibilités :
• première solution : calculer (en fonction de n ) le nombre d’opérations
élémentaires (addition, comparaison, affectation, …) requises par
l’exécution puis le multiplier par le temps moyen de chacune d’elle ;

• pour un algorithme avec essentiellement des calculs numériques, compter

les opérations coûteuses (multiplications, racine, exponentielle, …) ;

• sinon compter le nombre d’appels à l’opération la plus fréquente (cf. tableau1).

Ici, nous adoptons le point de vue suivant : l’exécution de chaque ligne de pseudo
code demande un temps constant. Nous noterons ci le coût en temps de la ligne i.

II.5.2 – Coût en séquentiel

Séquence : T séquence  n=∑ T éléments de la séquence n 
Alternative : si C alors J sinon K T  n =T C  n max {T J  n  , T K  n}
Itération bornée : pour i de j à k faire B T  n= k − j 1.T entête nT B nT entête  n .
Dans l’en-tête est mis l’affectation de l’indice et le test de continuation.
Itération non bornée : tant que C faire B T  n=Nbboucles . T B nT C nT C  n
avec Nbboucles le nombre de boucles qui s’évalue par méthode inductive.
Répéter B jusqu’à C T  n=Nbboucles . T B nT C n

Exemple 2
Fonction de multiplication de deux matrices
MULTIPLICATIONMATRICES(A,B)
entrée : deux matrices A, B n×n
sortie : matrice C n×n
1 n ← ligne[A]
2 Soit C une matrice n×n
3 pour i ← 1 à n
4 faire pour j ← 1 à n
5 faire c ij ← 0
6 pour k ← 1 à n
7 faire c ij ← c ij  aik . b kj
8 fin pour
9 fin pour
10 fin pour
11 retourner C

ASDD3 5

www.etudpdf.com
 Chapitre1:Introduction à la complexité algorithmique 2 année licence informatique

II.5.3 – Coût en récursif

La méthode "diviser pour régner" crée des algorithmes de type récursif.
Diviser pour régner
Cette méthode utilise trois étapes à chaque niveau de la récursivité :
a) Diviser : le problème en un certain nombre de sous-problèmes ;
b) Régner : sur les sous-problèmes en les résolvant de manière récursive.
Si la taille du sous-problème est assez petite, il est résolu immédiatement ;
c) Combiner : les solutions des sous-problèmes pour produire la
solution du problème originel.

Il faut trouver :

– la relation de récurrence associée ;

–

la base de la récurrence ;
– et les cas d’arrêt.
T  n est calculé grâce à des relations de récurrence.

Exemple 3
Fonction factoriel calculée par récursivité
FACTORIEL (n)
entrée : un entier n
sortie : n !
1 Si n1
2 alors retour ← 1
3 sinon retour ← n ×FACTORIEL( n−1 )
4 fin si
5 retourne retour

II.6 – Les différentes mesures de complexité

Il existe trois mesures différentes, la complexité dans le meilleur des cas, la
complexité en moyenne et la complexité dans le pire des cas. Mais la troisième
est beaucoup plus employée que les autres .
Soit A un algorithme, n un entier, Dn l’ensemble des entrées de taille n et une
entrée d ∈ Dn . Posons : coût A (d ) le nombre d’opérations fondamentales effectuées
par A avec l’entrée d .

II.6.1 – La complexité dans le meilleur des cas

Définition 3
Elle est obtenue par : Min A n=min{coût A d / d ∈ Dn } .

ASDD3 6

www.etudpdf.com
 Chapitre1:Introduction à la complexité algorithmique 2 année licence informatique

II.6.2 – La complexité en moyenne

C’est le temps d’exécution moyen ou attendu d’un algorithme. La difficulté pour ce
cas est de définir une entrée "moyenne" pour un problème particulier.

Définition 4
Moy A n= ∑ p d . coût A  d  avec p d  une loi de probabilité sur les entrées.
d ∈ Dn

Il reste à définir p d . Une hypothèse est que toutes les entrées ayant une taille
donnéesont équiprobables.
1
D’où : Moyenne uniforme A n= card  D  ∑ coût A  d 
n d∈D n

D’autres hypothèses se basent sur l’analyse probabiliste.

II.6.3 – La complexité dans le pire des cas

Définition 5:
Elle est donnée par : Max A n=max {coût A  d / d ∈ D n } .
C’est cette complexité qui est généralement calculée car c’est une borne
supérieure du temps d’exécution associé à une entrée quelconque.

Exemple 4
Tri à bulle
TRI-BULLE (A)
entrée : tableau A
sortie : tableau A trié par ordre croissant
1 Pour i ← 1 à longueur[A]
2 faire pour j ← longueur[A] décroissant jusqu’à i+1
3 faire si A[j] < A[j-1]
4 alors permuter A[j] ↔ A[j – 1]
5 fin si
6 fin pour
7 fin pour

II.6.4 – Calcul des complexités des exemples

a) Multiplication de deux matrices
L’algorithme est l’exemple 2 page 4.
Soient T  n le temps d’exécution en fonction de l’argument n et c i le coût en
temps de la ligne i.
Nous avons :
T  n=c 1c 2n[ c 3nc 4 c 5n c 6c7 ]

ASDD3 7

www.etudpdf.com
 Chapitre1:Introduction à la complexité algorithmique 2 année licence informatique
T  n=c 1c 2c 3 . n c 4c 5 . n2 c 6c 7. n3
Ainsi T ∈( n3 ) pour les trois complexités.
b) Factoriel
L’algorithme est l’exemple 3 page 5.
Soit T  n le temps d’exécution en fonction de l’argument n .
À la base T 1=c 1c 2
Sinon T  n=c 1c 3T n1  pour n1
Démontrons que T  n=c 1c 2n-1c 1c 3  pour n1
Pour n=1 : vrai.
Nous le supposons vrai au degré n .
Démontrons-le au degré n1 .
T  n1=c 1c3 T n
T  n1=c 1c3c 1c 2n -1 c1c 3=c1c 2n c 1c 3 
Comme la proposition est vraie au degré 1, et si elle est vraie au degré
n , elle est vraie au degré n1 , d’après le principe de récurrence, elle est vraie
quel que soit n .
Donc T  n= n
c) Recherche dichotomique
L’algorithme est l’exemple 1 page 1.
Calcul de la complexité dans le meilleur des cas : l’élément A[ milieu]=v .
T  n vaut donc :
T  n=c 1c 2c3 c 4c5c 6c 7 c25c 26
T  n= 1
Calcul de la complexité dans le pire des cas : v ne figure pas dans A .
Supposons que v est plus grand que tous les éléments de A .
T  n vaut donc :
T  n=c 1c 2c3 x.
c 4c 5c 6c8 c 9c 10c 11c 12c 16c 24c 25c 26
L’algorithme passe x fois dans la boucle répéter jusqu’à ce que début>=fin

Calculons x. Pour cela, nous allons émettre une hypothèse puis la démontrerpar
récurrence.
T  n est du type : T  n=C 1C 2 x avec C 1 , C 2 des constantes.
Si n=2 ou n=3 , x=1 .
Si n=4 ou n=5 , x=2 .
Si n=8 ou n=9 , x=3.
En fait, C 1 est le temps pour initialiser l’algorithme et C 2 x le temps nécessaireà
l’algorithme pour gérer le tableau de taille n . Posons T ' n le temps pour
effectuer la boucle pour une taille n .
Par la suite, pour simplifier, nous supposons que la taille du problème initial estune
puissance de deux.

ASDD3 8

www.etudpdf.com
 Chapitre1:Introduction à la complexité algorithmique 2 année licence informatique
Démontrons que T '  n=C 2 . log 2  n  .
Nous le supposons vrai …
au niveau n .
Démontrons-le au niveau 2 n .
T ' 2n =C 2T '  n =C 2C 2 .log 2  n=C 21 log2  n =C 2 log 22 log2  n=C 2 log 2 2n 
Comme la proposition est vraie au degré 1, et si elle est vraie au degré n , elle
est vraie au degré 2 n , d’après le principe de récurrence, elle est vraie quel que
soit n puissance de 2.
D’où
T  n=C 1T ' n=C 1 C 2 . log 2 n∈ 1 log 2  n
D’où T (n)∈Θ(log 2 ( n))

Remarque
Question ouverte : Quelle est la complexité d’un tri dichotomique ?
Réponse : n log 2 (n)
d) Tri à bulle
L’algorithme est l’exemple 4 page 6.
Calcul de la complexité dans le meilleur des cas : le tableau est déjà trié par
ordre croissant. La quatrième ligne n’est jamais exécutée.
n n
T ( n)=∑ ( c1 + ∑ ( c 2+ c 3 ))
i=1 j=i+ 1
n n n
= ∑ c 1+ ∑ ∑ (c 2+ c 3)
i=1 i=1 j =i + 1

n n n
=c 1 . ∑ 1+ (c 2+ c3 ). ∑ ∑ 1
i=1 i=1 j =i + 1
n
=c 1 . n+ ( c 2+ c 3) . ∑ (n−i)
i=1
n n n

∑ (n−i)=∑ n−∑ i
i=1 i=1 i=1
12
=n − n( n+ 1) *
2
2 1 2 1
=n − n − n
2 2
1 2 1
= n− n
2 2
1 1
T ( n)=c 1 . n+ (c 2+ c 3).( n2 − )
2 2
(c 2+ c 3) 2 2c 1−c 2−c 3
= n+ n
2 2
D’où T  n∈ n 2

Calcul de la complexité dans le pire des cas : le tableau est trié par ordre
décroissant

n
* Rappel : la sommation d’une série arithmétique a pour valeur ∑ k = 12 n n1 
k=1

ASDD3 9

www.etudpdf.com
 Chapitre1:Introduction à la complexité algorithmique 2 année licence informatique

La quatrième ligne est toujours exécutée. Nous avons donc :

n n
T  n=∑  c1 ∑  c 2c 3c 4 
i=1 j=i1
1 1
=c 1 . n+ (c2 + c 3+ c 4 ).( n 2− )
2 2
(c 2+ c3+ c 4) 2 2c1−c 2−c 3−c 4
= n+ n
2 2
D’où T  n∈ n 2

L’algorithme tri à bulle est donc dans tous les cas de complexité  n 2 .

Remarque
Quand un algorithme contient une structure de contrôle itératif comme une boucle
tantque ou pour, nous obtenons comme dans l’exemple ci-dessus des sommations
qui nous
ramènent à des séries.

II.7 – Comparaison de deux algorithmes

II.7.1 – Méthode de comparaison

Si le nombre d’entrées utilisées pour un algorithme est très faible, généralement le
tempsd’exécution de l’algorithme l’est aussi. Ce qui nous intéresse, c’est
comment va réagirl’algorithme pour un nombre important de données.
Donc pour comparer deux algorithmes, nous allons comparer leur taux de
croissance ou ordre de grandeur .

Définition 6
Efficacité d’un algorithme par rapport à un autre
« On considère généralement qu’un algorithme est plus efficace qu’un autre si son temps
d’exécution du cas le plus défavorable a un ordre de grandeur inférieur. » (Th. H. Cormen,
Ch. E. Leiserson, R. L. Rivest, C. Stein 9).

C’est pour ces raisons que la notation O 10 est souvent utilisée pour la mesure de la
complexité car elle décrit une borne supérieure du cas le plus défavorable.

II.7.2 – Classification des algorithmes

M. T. FDIL11 illustre la classification par des explications.
Les algorithmes habituellement rencontrés peuvent être classés dans les catégories
suivantes :

ASDD3 10

www.etudpdf.com
 Chapitre1:Introduction à la complexité algorithmique 2 année licence informatique

Complexité Description
Complexité O1 L’exécution ne dépend pas du nombre d’éléments en entrée
mais s’effectue toujours en un nombre constant
Complexité constante ou
d’opérations
temps constant

Complexité O logn La durée d’exécution croît légèrement avec n . Ce cas de

Complexité logarithmique. figure se rencontre quand la taille du problème est divisée
par une entité constante à chaque itération.

Complexité O n C’est typiquement le cas d’un programme avec une boucle

Complexité linéaire de 1 à n et le corps de la boucle effectue un travail de
durée constante et indépendante de n .

Complexité O n logn Se rencontre dans les algorithmes où à chaque itération la

Complexité n- taille du problème est divisée par une constante avec à
logarithmique chaque fois un parcours linéaire des données. Un exemple
typique de ce genre de complexité est l’algorithme de tri
"quick sort" qui, de manière récursive, divise le tableau à
trier en deux morceaux par rapport à une valeur particulière
appelée pivot, trie ensuite la moitié du tableau puis l’autre
moitié … S’il n’y avait pas cette opération de "division"
l’algorithme serait logarithmique puisqu’on divise par 2 la
taille du problème à chaque étape. Mais, le fait de
reconstituer à chaque fois le tableau en parcourant
séquentiellement les données ajoute ce facteur n au
log n . Noter que la complexité n-logarithmique est
tributaire du bon choix du pivot.

Complexité O n2  Typiquement c’est le cas d’algorithmes avec deux boucles

Complexité quadratique imbriquées chacune allant de 1 à n et avec le corps de la
boucle interne qui est constant.

Complexité O n3  Idem quadratique mais avec ici par exemple trois boucles
Complexité cubique imbriquées.

Complexité O n p  Algorithme dont la complexité est de la forme O  n p  pour

Complexité polynomiale un certain p . Toutes les complexités précédentes sont
incluses dans celle-ci .

Complexité O 2n  Les algorithmes de ce genre sont dits "naïfs" car ils sont
Complexité exponentielle inefficaces et inutilisables dès que n dépasse 50.

Tableau 2 : classification des algorithmes

Dénition 7
À l’inverse d’un algorithme naïf (complexité exponentielle) et par convention, un
algorithmeest dit praticable, efficace s’il est polynomial.

ASDD3 11

www.etudpdf.com
Algorithmique et structure de données 3 Univ Batna-2- Chapitre4 : Arbres binaires

PARTIE I : DÉFINITIONS & TERMINOLOGIES

Un arbre est une structure de données (souvent dynamique) représentant un ensemble de valeurs
organisées hiérarchiquement (non linéaire). Chaque valeur est stockée dans un nœud. Les nœuds sont
connectés entre eux par des arêtes qui représentent des relations parent/fils.

 Racine : est le nœud qui n'a pas de prédécesseur (parent) et possède zéro ou plusieurs fils. La
racine constitue la caractéristique d'un arbre.
 Feuille : est un nœud qui n'a pas de successeur (fils). Une feuille est aussi appelée un nœud
externe.
 Nœud interne : est tout nœud qui admet au moins un successeur (fils)

 Fils d’un nœud : sont ses successeurs. Dans l'exemple, F, G, H, et I sont les fils du nœud D.
 Frères : sont les successeurs ou les fils issus d'un même nœud (parent direct). Dans
l'exemple, B, C et D sont des frères.
 Père : est un nœud qui admet au moins un successeur (fils).
Dans l'exemple, D est le père des nœuds F, G, H et I.
 Sous arbre : est une portion de l'arbre. Dans l'exemple, le nœud G avec ces deux fils J et K
constituent un sous arbre.
 Une branche : est une suite de nœuds connectés de père en fils (de la racine à une feuille).
 A-B-E
 A-C
 A-D-F
 A-D-G-J
 …..
1

www.etudpdf.com
Algorithmique et structure de données 3 Univ Batna-2- Chapitre4 : Arbres binaires

 Descendants d’un nœud : sont tous les nœuds du sous arbre de racine nœud. Dans
l'exemple, les descendants de D sont F, G, H, I, J, K et L.
 Ascendants d’un nœud : sont tous les nœuds se trouvant sur la branche de la racine vers ce
nœud. Dans l'exemple, les ascendants de J sont G, D et A. Les ascendants de E sont B et A.
 Taille d’un arbre: est le nombre de nœuds qu’il possède.
 Taille de l’arbre dans l’exemple = 12
 Un arbre vide est de taille égale à 0.
 Degré d’un nœud : est le nombre de ses fils. Dans l'exemple, le degré de B est 1, le degré
de D est 4.
 Degré d’un arbre : est le degré maximum de ses nœuds.
 Degré de l’arbre dans l’exemple = 4
 Le niveau d'un nœud : est la distance qui le sépare de la racine :
 Le niveau de la racine = 0
 Le niveau de chaque nœud est égale au niveau de son père plus 1
 Le niveau du nœud contenant ‘G' est égal à 2.

 La profondeur d'un arbre (ou sa hauteur) : est le plus grand niveau, c-à-d la distance
entre la racine et la feuille la plus lointaine. Dans l'exemple, la profondeur de l'arbre est
égale à 3.
o Définition récursive :
Cas particulier : NIL est un arbre vide, contenant zéro nœud.
Cas général : Si n est un nœud et si T1, T2, ...Tm sont des arbres, ALORS on peut construire un
nouvel arbre en connectant T1, T2, ...Tm comme des fils à n.
- Chaque Ti est définit de la même manière (récursivement). Donc T1, T2, ...Tm sont alors
des sous- arbres de n

www.etudpdf.com
Algorithmique et structure de données 3 Univ Batna-2- Chapitre4 : Arbres binaires

PARTIE II: ARBRES BINAIRES

1- DÉFINITIONs
Un arbre binaire est un arbre où chaque nœud est connecté à deux sous arbres (un sous arbre gauche
et un sous arbre droit). Donc, un arbre binaire est un arbre de degré 2, c’est-à-dire que chaque nœuds
a au plus deux fils. Ainsi, le premier fils d'un nœud n est appelé Fils-Gauche (FG) et le deuxième fils
est appelé Fils-Droit (FD)

 Un arbre binaire est dit strictement binaire si chaque nœud interne (non feuille) a exactement
2 fils différents de NIL.
 Si un arbre strictement binaire a n feuilles Alors :
le nombre total de ses nœuds = 2n-1.
Le nombre de ses nœuds non feuilles (nœuds internes) = n-1.
Le nombre de feuilles : n=6 (C, D,H, M, J, K)
Le nombre total de nœuds : 2n-1=11
Le nombre de nœuds internes : n-1=5 (A, B, F, G, I)
 Un arbre binaire complet est un arbre strictement binaire où toutes les feuilles sont au
même niveau.
 Dans un arbre binaire complet de profondeur « d » :
 le nombre total de nœuds n = 20 + 21 + 22 + ... 2d = 2d+1-1
 ainsi, d = log2(n+1) – 1
 le nombre de nœuds internes = 2d-1
 le nombre de feuilles = 2d
 le nombre de nœuds dans le niveau i = 2i

Dans l’exemple ci-dessus :

 d=2

www.etudpdf.com
Algorithmique et structure de données 3 Univ Batna-2- Chapitre4 : Arbres binaires

 le nombre total de nœuds n = 23-1 = 7

 le nombre de nœuds internes = 22-1 = 3
 le nombre de feuilles = 22 = 4
 le nombre de nœuds dans le niveau 1 = 2
2- MODÈLE :
L'arbre est implémenté souvent de manière dynamique comme un ensemble de maillons (nœuds)
chaînés entre eux.
 La structure d'un nœud de l'arbre est la suivante :

 On définit le modèle (machine abstraite) suivant d’un arbre binaire :

3- PARCOURS d’un arbre binaire :

- Le parcours d’un arbre consiste à passer par tous ses nœuds.
- Les parcours permettent d’effectuer tout un ensemble de traitement sur les arbres.
- On distingue deux types de parcours :
- Des parcours en largeur explorent l'arbre niveau par niveau.
- Des parcours en profondeur explorent l'arbre branche par branche.
3.1- Les Parcours En Profondeur :
Dans un parcours en profondeur, on descend le plus profondément possible dans l’arbre puis, une
fois qu’une feuille a été atteinte, on remonte pour explorer les autres branches en commençant
par la branche « la plus basse » parmi celles non encore parcourues.
4

www.etudpdf.com
Algorithmique et structure de données 3 Univ Batna-2- Chapitre4 : Arbres binaires

Le parcours en profondeur peut se faire en :

- Préordre (Préfixe) : où on affiche la racine avant ses fils (Racine FG FD),
- Inordre (Infixe) : où on affiche le fils gauche avant sa racine et son frère droit (FG Racine
FD),
- Postordre (Postfixe) : où on affiche les fils avant leur racine (FG FD Racine).
 Ces parcours (préordre, inordre et postordre) sont des parcours simples à définir et à programmer
(en récursif).
 Soit R un arbre binaire (pouvant être vide : R=NIL).
 S'il n'est pas vide (n pointe le nœud racine), alors il a la forme suivante (avec T1 et T2 des
sous arbres définis de la même manière que n) :

3.1.1- Le parcours préordre : de R (s'il n'est pas vide) consiste à visiter le nœud racine (R)
ensuite parcourir récursivement en préordre les sous arbres T1 (sous arbre gauche) puis T2
(sous arbre droit) ce qui donne : [ R , T1 , T2 ou RGD].

 La procédure (récursive) qui affiche les valeurs en parcours préordre d’un arbre de racine R
est :
Procédure Préordre( R:ptrN)
Début
SI R ≠ NIL
ecrire( Info(R) )
Préordre( FG(R) )
Préordre( FD(R) )
FSI
fin

3.1.2- Le parcours inordre de R (s'il n'est pas vide) consiste d'abord à parcourir
récursivement en inordre le sous arbre gauche T1, puis visiter le nœud racine (R)
ensuite parcourir récursivement en inordre le sous arbre droit T2 ce qui donne :
[ T1, R , T2 ou GRD ].

www.etudpdf.com
Algorithmique et structure de données 3 Univ Batna-2- Chapitre4 : Arbres binaires

La procédure (récursive) qui affiche les valeurs en parcours inordre d’un arbre de racine R est :
Procédure Inordre( R:ptrN )
Début
SI R ≠ NIL
Inordre( FG(R) )
ecrire( Info(R) )
Inordre( FD(R) )
FSI
fin

3.1.3- Le parcours postordre de R (s'il n'est pas vide) consiste d'abord à parcourir récursivement
en postordre les sous arbres T1 puis T2 ensuite visiter le nœud racine (R) ce qui donne [
T1 , T2 , R ou GDR]

La procédure (récursive) qui affiche les valeurs en parcours postordre d’un arbre de racine R est :
Procédure Postordre( R: ptrN)
Début
SI R≠NIL
Postordre( FG(R) )
Postordre( FD(R) )
ecrire( Info(R) )
FSI
fin
NB : On peut faire ces trois parcours sans utiliser la récursivité. Il faudra alors un moyen pour
pouvoir remonter dans les branches de l’arbre :
- On pourra par exemple utiliser une structure de pile pour sauvegarder les adresses des
nœuds par lesquels on est descendu et les dépiler quand on en aura besoin pour remonter.
- On peut aussi enrichir la structure des nœuds en incluant un pointeur vers le nœud père

www.etudpdf.com
Algorithmique et structure de données 3 Univ Batna-2- Chapitre4 : Arbres binaires

3.2- PARCOURS EN LARGEUR

Dans le parcours par niveau, tous les nœuds d’un même niveau sont traités avant de descendre au
niveau suivant.

 Dans le parcours par niveau, tous les nœuds d’un même niveau sont traités avant de
descendre au niveau suivant.
Procédure parcours_largeur( R:ptrN )
Var F:filed’attente; P: ptrN;
Debut
P←R;
Si R ≠ NIL Alors
Enfiler(F,P);
TQ (Non FileVide(F))
Defiler(F,P);
écrire(info(P));
Si FG(P) ≠ NIL Alors Enfiler(F,FG(P));
Si FD(P) ≠ NIL Alors Enfiler(F,FD(P));
FTQ
Fin

PARTIE III: ARBRES BINAIRES DE RECHERCHE(ABR)

1-Définition : Un Arbre Binaire de Recherche (ABR) est un arbre binaire ordonné tel que pour
tout nœud« i »:
- Toutes les valeurs du sous arbre gauche de « i » sont strictement inférieures à la valeur
(ou clé) de « i », et
- Toutes les valeurs du sous arbre droit de « i » sont supérieures ou égales à la valeur (ou
clé) de « i ».

Intérêt de cette propriété : diminuer la complexité temporelle de recherche, d’insertion et de

suppression dans l’arbre.
7

www.etudpdf.com
Algorithmique et structure de données 3 Univ Batna-2- Chapitre4 : Arbres binaires

2- Opération De Recherche :
La recherche est dichotomique, à chaque étape, un sous arbre est éliminé :
- Rechercher (55)
- Rechercher (FD(20))
- Rechercher (FG(59))
- Rechercher (FD(27))
- Rechercher (FD (33))
- Élément trouvé

Fonction de recherche récursive :

Fonction RechercherABR_rec (R: ptrN, x: entier) : ptrN
Debut
Si R =Nil alors
Retourner (Nil)
Sinon
Si Info (R) = x alors
Retourner (R)
Sinon
Si Info(R)>x alors
Retourner (RechercherABR_rec(FG(R), x))
Sinon
Retourner (RechercherABR_rec(FD(R), x))
Fin

Fonction de recherche itérative :

Fonction RechercherABR _iter(R:ptrN, x: entier) : ptrN
Debut
TQ R ≠Nil faire
Si Info (R) = x alors
Retourner (R)
Sinon
Si Info(R)>x alors
R←FG(R)
Sinon
R←FD(R)
FTQ
Retourner (Nil)
Fin

4- Opération D’insertion
L'insertion d'un élément se fait toujours au niveau d'une feuille. Cette insertion dans un ABR doit
maintenir la propriété d’ordre des arbres de recherche. Ainsi:
1. Rechercher la position d’insertion
8

www.etudpdf.com
Algorithmique et structure de données 3 Univ Batna-2- Chapitre4 : Arbres binaires

2. Raccorder le nouveau nœud à son parent

- Rechercher Position (25)
- Rechercher (FD(20))
- Rechercher (FG(59))
- Position trouvé pour l’insertion, le père est le nœud 27
- Insérer 25 au niveau de la feuille dont le père est 27
Fonction d’insertion récursive :
Fonction InsererABR_rec (R:ptrN, x: entier) : ptrN
Debut
Si R =Nil alors
R←CreerNoeud(x)
Sinon
Si Info(R)>x alors
Aff_FG(R, InsererABR_rec(FG(R), x))
Sinon
Aff_FD(R, InsererABR_rec(FD(R), x))
Retourner (R)
Fin
Fonction d’insertion Itérative :
Fonction InsererABR_iter (R:ptrN, x: entier) : ptrN
Var P, Q: *Tnoeud
Debut
P←CreerNoeud(x)
Si R =Nil alors
R←P
Sinon
Inserer ← faux; Q ←R
TQ (non inserer) faire
Si Info(Q)>x alors
Si FG(Q) =Nil alors
Aff_FG(Q, P); inserer ←vrai ;
Sinon Q←FG(Q)
Sinon
Si FD(Q)=Nil alors
Aff_FD(Q, P); inserer vrai
Sinon Q←FD(Q)
Retourner (R)

www.etudpdf.com
Algorithmique et structure de données 3 Univ Batna-2- Chapitre4 : Arbres binaires

5- Opération De Suppression
Pour supprimer le nœud « i » d’un ARB, il faudra le rechercher. Une fois le nœud « i » trouvé, on se
trouve dans une des situations suivantes :
Cas 1: Suppression d'une feuille : Il suffit de l'enlever de l'arbre vu qu'elle n'a pas de fils.
Exemple: supprimer le nœud i qui contient la valeur 8 :
1. Rechercher(8)
2. Libérer le nœud « i »

Cas 2: Suppression d'un nœud avec un fils : Il faut l'enlever de l'arbre en le remplaçant par son
fils.
Exemple: supprimer le nœud « i » qui
contient la valeur 10 :
1. Rechercher(10)
2. Chainer le père de i avec le FD(i)
« Chainer le père de i avec le FG(i) »
3. Libérer le nœud « i »

Cas 3: Suppression d'un nœud avec deux fils

Etape 1: On échange le nœud à supprimer avec son successeur le plus proche (le nœud le plus à
gauche du sous-arbre droit) ou son plus proche prédécesseur (le nœud le plus à droite du sous-arbre
gauche). Cela permet de garder une structure d'arbre binaire de recherche.

10

www.etudpdf.com
Algorithmique et structure de données 3 Univ Batna-2- Chapitre4 : Arbres binaires

Cas A: On échange le nœud à supprimer avec son successeur le plus proche (le nœud le plus à
gauche ou le plus petit du sous-arbre droit).
- Racine: 71
- La plus petite valeur : 69

Fonction Successeur (R: ptrN): ptrN

Debut
RFD(R)
Si R≠Nil alors
TQ FG(R)≠Nil faire RFG(R)
Retourner (R)
Fin
Cas B: On échange le nœud à supprimer avec son plus proche prédécesseur (le nœud le plus à
droite ou le plus grand du sous-arbre gauche).
- Racine: 50
- La plus grande valeur : 56

11

www.etudpdf.com
Algorithmique et structure de données 3 Univ Batna-2- Chapitre4 : Arbres binaires

Fonction Predecesseur (R: ptrN): ptrN

Debut
RFG(R)
Si R≠Nil alors
TQ FD(R)≠Nil faire RFD(R)
Retourner (R)
Fin
Etape 2: on applique à nouveau la procédure de suppression qui est maintenant une feuille ou un
nœud avec un seul fils.
 Ainsi, si on choisit d’échanger le nœud « 66 » avec son plus proche successeur « 69 », on
obtient

 Ainsi, si on choisit d’échanger le nœud « 66 » avec son plus proche prédécesseur « 56 », on

obtient.

12

www.etudpdf.com
Algorithmique et structure de données 3 Univ Batna-2- Chapitre4 : Arbres binaires

Fonction SupprimerABR_iter (R:ptrN, x: entier) : ptrN

Var P, Q: ptrN
Debut
RechercherABR (R, x, Q, P)
Si Q ≠Nil alors // l’élément x existe dans Q
Fin faux
TQ non fin faire
Si FG(Q) =Nil alors
Si FD(Q) =Nil alors //Cas n°1: Q est une feuille
Chaîner (R, P, Q, Nil)
Sinon //Cas n°2: Q possède un FD
Chaîner (R, P, Q, FD(Q))
Sinon
Si FD(Q) =Nil alors //Cas n°2: Q possède un FG
Chaîner (R, P, Q, FG(Q)) ; Fin vrai
Sinon // Cas n°3: Q possède deux fils
Successeur (Q, S, PS)
Aff_Info (Q, Info(S))
QS; PPS; xInfo(S)
FTQ
LibererNoeud(Q)
FSI
Retourner (R)
Fin

Procédure Rechercher ABR (R: ptrN, x: entier, Var Q: ptrN, Var Père: ptrN) :
Cette procédure retourne l’adresse du nœud contenant x (soit Q) ainsi que l’adresse
de son père (soit Père).
Procedure RechercherABR (R: ptrN, x:entier, Var Q: ptrN, Var Père: ptrN)
Debut
Père Nil; Q Nil;
TQ R ≠Nil faire
Si Info (R) = x alors
QR
Sinon
PèreR
Si Info(R)>x alors
RFG(R)
Sinon
RFD(R)
FTQ
Fin

13

www.etudpdf.com
Algorithmique et structure de données 3 Univ Batna-2- Chapitre4 : Arbres binaires

 Procedure Chaîner (R, P, Q, Nil) : Cette procédure permet de chaîne le père

de Q (P) avec le Fil de Q selon la valeur de Q
Procedure Chaîner (Var R: ptrN , PèreQ, NoeudQ, FilsQ: ptrN)
Début
Si PèreQ =Nil alors
RFilsQ
Sinon
Si Info(PèreQ)>info(NoeudQ) alors
Aff_FG(PèreQ, FilsQ)
Sinon
Aff_FD(PèreQ, FilsQ)
Fin
 Successeur (Q, S, PS) : Cette procédure retourne l’adresse du successeur de Q (S)
ainsi que l’adresse de son père (PS)
Procédure Successeur (R: ptrN, Var S, PS: ptrN)
Début
PSR; SFD(R)
Si (S≠Nil) alors
TQ FG(S)≠Nil faire PSS; SFG(S)
Fin

Fonction de suppression Version récursive

Fonction SupprimerABR_rec (R: ptrN, x: entier) : ptrN
Debut
Si R =Nil alors
Retourner (R)
Sinon
Si Info(R)>x alors
Aff_FG(R, SupprimerABR_rec(FG(R), x))
Retourner (R)
Sinon
Si Info(R)<x alors
Aff_FD(R, SupprimerABR_rec(FD(R), x))
Retourner (R)
Sinon // Info(R) = x
Retourner (SupprimerRacine (R))
Fin

14

www.etudpdf.com
Algorithmique et structure de données 3 Univ Batna-2- Chapitre4 : Arbres binaires

Fonction Supprimer racine :

Fonction SupprimerRacine (R:ptrN) : ptrN
Debut
Si FG(R) =Nil alors
Si FD(R) =Nil alors //Cas n°1: R est une feuille
LibérerNoeud(R)
Retourner (Nil)
Sinon //Cas n°2: R possède un FD
DFD(R)
LibérerNoeud(R)
Retourner (D)
Sinon
Si FD(Q) =Nil alors //Cas n°2: R possède un FG
GFG(R)
LibérerNoeud(R)
Retourner (G)
Sinon // Cas n°3: R possède deux fils
SSuccesseur (R)
Aff_Info (R, Info(S))
Aff_FD(R, SupprimerABR_rec(DF(R), Info(S)))
Retourner (R)
Fin

15

www.etudpdf.com