Cours Algorithmique Et Complexite Avancee

Chap-1 : Introduction & motivations
1- Qu’est-ce que l’algorithmique ?
1.1 - Définition (Algorithme).
Un algorithme est une suite finie d’opérations élémentaires constituant un schéma de

calcul ou de résolution d’un problème.
1.2 - Définition (Algorithmique)
L’algorithmique désigne le processus de recherche d’algorithme :
1.3 - Différences entre algorithmes et programmes
Un programme est la réalisation (l’implémentation) d’un algorithme au moyen d’un

langage donné (sur une architecture donnée). Il s’agit de la mise en oeuvre du
principe. Par exemple, lors de la programmation on s’occupera parfois, explicitement
Notes de cours : Algorithmique & Complexité 1/136 Hamrouni Kamel

de la gestion de la mémoire (allocation dynamique en C) qui est un problème
d’implémentation ignoré au niveau algorithmique.
1.4 - Qualités exigées d’un bon algorithme
Un bon algorithme doit satisfaire les qualités suivantes:
Correct: Il faut que le programme exécute correctement les tâches pour lesquelles il a
été conçu
Complet: Il faut que le programme considère tous les cas possibles et donne un
résultat dans chaque cas.
Efficace: Il faut que le programme exécute sa tâche avec efficacité c’est à dire avec
un coût minimal. Le coût pour un ordinateur se mesure en termes de
temps de calcul et d’espace mémoire nécessaire.

2- Problème_1 : Valeur d’un polynôme
On voudrait élaborer un algorithme permettant de calculer pour une valeur X donnée
de type REAL la valeur numérique d'un polynôme de degré n:
P(X) = anXn + an-1Xn-1 + ... + a1X + a0
Données : n et les coefficients an, ... , a0 et x
Objectif : calcul de P(X)

2.1 - Algorithme_1 ( trivial) :
begin
Coût de l’algorithme:
P=0
- (n+1) additions
for k=0 to n do
- (n+1)
P = P+ ak*XK
multiplications
endfor
- (n+1) puissances
end

2.2 - Algorithme_2 (sans puissance) :
begin
XP=1 ; P =0
for K=0 to N do
P = P+ XP*ak
XP = XP * X
endfor
end Coût de l’algorithme:
- (n+1) additions
- 2(n+1)
multiplications

2.3 - Algorithme_3 (Schéma de Horner):
Le schéma de Horner est illustré par la figure ci-contre :
P(x) = (….(((anx+an-1)x+an-2)x+an-3)…..)x+a0
 l’algorithme
begin
P = an
for k = n-1 to 0 step –1 do
P = P*X + ak
endfor
end
- (n) additions …. Peut-on faire mieux ?
- (n)
multiplications

3- Problème-2: La plus grande somme contiguë
Le but est d’élaborer un algorithme permettant de calculer la plus grande somme
contiguë d'une séquence d'entiers placés dans un tableau.
Étant donné un tableau A[0..n1] de n nombres entiers positifs ou négatifs, comment

déterminer la valeur maximale des sommes correspondantes aux sections de la forme
A[i..j[. On notera que 0 est la somme de n'importe quelle section vide A[i..i[.
Par exemple, si le tableau contient les dix éléments:
i 0 1 2 3 4 5 6 7 8 9
A 31 -41 59 26 -53 58 97 -93 -23 84
la somme maximale est A[2..7[= A[2..6] = 187.

3.1 - Algorithme_1 (naïf) :
L'idée la plus simple est de calculer toutes les sommes et de rechercher la plus
grande, par un algorithme du style:
Algorithme_1 (int n , int a[ ])

Maximum=0;
For i=0 to n-1 do
For j=i to n-1 do
Somme=0
For k=i to j do
Somme= Somme + a[k]
Il est facile de voir que la Endfor
comparaison entre If (Somme > Maximum) then
Maximum et Somme est Maximum = Somme effectuée
O(n3) fois. Endfor
Endfor
Return Maximum
End_algorithme
..\Exemples\plus_grande_somme_1.cpp

Peut-on mieux faire ?
3.2 - Algorithme_2 :
Une meilleure idée consiste à ne pas recalculer systématiquement les sommes mais à
utiliser la relation:
j 1 j
Algorithme_2 (int n , int a[ ])
k i
a k  
k i
a k  a j 1
Maximum=0;
For i=0 to n-1 do
D'où le nouveau programme: Somme=0
For j=i to n-1 do
Somme= Somme + a[j]
If (somme > maximum) then
Maximum = Somme
Endfor
Endfor
Return Maximum
End_algorithme
Cette version n'effectue plus que O(n2) additions.

..\Exemples\plus_grande_somme_2.cpp
On peut essayer une approche dichotomique en coupant le tableau en deux parties de

tailles équivalentes et en disant que la somme maximale est réalisée soit totalement
dans la partie droite, soit totalement dans la partie gauche, soit à cheval. La valeur
recherchée est nécessairement la plus grande des trois sommes. Cette idée nous
conduit à l’algorithme récursif suivant :

Algorithme_3(int a[ ], int g, int d) max2= 0 ; somme =0;
{ int m, max1, max2, maximum ; for i=m+1 to d do
int somme, i; somme= somme+ a[i];
if (somme > max2) then
if (g > d ) then max2= somme;
return 0; endfor
endif
if (g ==d ) then maximum = max1 + max2;
if (a[g] > 0 )
return a[g]; somme= algorithme_3 (a, g, m);
else if ( somme > maximum ) then
return 0; maximum =somme;
endif endif
m= (g+d)/2; somme= algorithme_3 ( a, m+1 , d);

max1=0; somme = 0; if ( somme > maximum ) then
for i=m to g step -1 do maximum =somme;
somme = somme +a[i]; endif
if (somme > max1) return maximum;

max1= somme;
endfor End_algorithme
 ..\Exemples\plus_grande_somme_3.cpp
On invoque cette fonction par l'appel algorithme_3 (a, 0, n-1).
Complexité de l’algorithme :
Cet algorithme est de type « diviser pour régner ». Le nombre de comparaisons
effectuées à l’intérieur de la fonction récursive est égal à (d-g) fois. Il est donc O(n).
L’équation récurrente de sa complexité est donc:
On démontrera plus loin en utilisant le théorème qui sera présenté au chapitre suivant
que :
T(n) = O(n log(n)).
Car :
T(n) = 2T(n/2) + O(n)


Mais on peut encore mieux faire. L'idée cette fois est de parcourir une seule fois le
tableau et de maintenir simultanément deux maximums : la plus grande somme
« max1 » et un « max2 » qui est remis à zéro chaque fois qu’il devient négatif. La plus
grande somme recherchée est égale soit à « max1 » soit à « max2 » d'où l'algorithme:
..\Exemples\plus_grande_somme_4.cpp int algo_4(int a[ ], int n)

int max1 = 0, max2 = 0, i ;
for i = 0 to n-1 do
Il est clair que cet algorithme est en O(n). max2 = max2 + a[i] ;
if (max2 < 0) then
Peut-on mieux faire ? max2 = 0 ;
endif
La réponse est non car tout algorithme if (max2 > max1) then
résolvant ce problème est obligé de max1 = max2 ;
parcourir l'intégralité des données, donc a endif une
complexité au moins linéaire. endfor
return max1 ;
End_algorithme

Sur un PC à 400MHz, pour un tableau de taille 107 Jon Bentley, (Programming Pearls,
Addison-Wesley, 2000) ) donne l'estimation suivante des temps d'exécution:
Algorithme 1 2 3 4
Temps 41000 ans 1,7 semaines 11 secondes 0,48 seconde

4- Problème_3 : calcul de xn
Données : Un entier naturel n et un réel x.
Objectif : Calculer xn.
Idée : Nous partons de y1 = x. Nous allons construire une suite de valeurs y1, ...,
ym telle que la valeur yk soit obtenue par multiplication de deux puissances
de x précédemment calculées : yk = yu *yv, avec 1<=u , v < k, k
appartient à [2,m].
But : ym = xn. Le coût de l’algorithme sera alors de m-1 = nombre de

multiplications faites pour obtenir le résultat recherché.
4.1 - Algorithme trivial
yi = yi-1*y1 , i appartient à [2,n]. Résultat : yn = xn. Coût = n-1 multiplications.
Algorithme
y=x
For i =2 to n do
y=y*x
End_for

Return y
End_Algorithme
4.2 - Méthode binaire ou méthode de « la chaîne Chinoise »
Historique :
Cette méthode a été présentée 200 avant J.C. en Inde (ou en Chine), mais il
semblerait qu’il ait fallu attendre un millénaire avant que cette méthode ne soit connue
en dehors de l’Inde [Knuth].
Algorithme Illustration avec x23
1. Écrire n sous forme binaire 1. n = 23 = 10111
2. Remplacer chaque : 1 0 1 1 1
– « 1 » par la paire de lettres « 2. SX S SX SX SX
SX » ;
– « 0 » par la lettre « S ».
3. Éliminer la paire « SX » 3. S SX SX SX
la plus à gauche.
4. Résultat : Une chaîne de caractères 4. Résultat : SSXSXSX
contenant les lettres S et X.
5. Calcul de xn : 5. Nous partons de x et nous obtenons
- partir de x et parcourir la chaîne successivement :

de caractères x,x2, x4, x5, x10, x11, x22, x23.
- à chaque S 
« élever au carré » ; Nous sommes donc capables de
- à chaque X  calculer x23 en 7 multiplications au lieu
« multiplier par x ». de 22
Explication de la méthode
p
– Écriture binaire de n : n   ai 2 i
i 0
- Plaçons nous au cours du calcul de puissances de x. Soit j le dernier bit de la

représentation binaire de n qui a été « décodé » et soit yj le dernier résultat obtenu.
(Initialement, j = p et yp = x = xap ). j varie de p à 0.
– Deux cas sont possibles pour aj-1 :

1er cas : aj-1 = 1 alors aj-1 est remplacé par SX, nous élevons yj au carré
puis multiplions le résultat par x. Le nouveau résultat est :
y j 1  y 2j x
2ème cas : aj-1 =0 alors aj-1 est remplacé par S et nous élevons simplement yj
au carré. Le nouveau résultat est y j 1  y j
2
a
Dans tous les cas nous avons : y j 1  y 2j x j 1

– D’où :
a p 1 a a p 1 2a p a p 1 2 a p  a p 1
y p 1  y 2p x  (x p )2 (x )  (x )( x )  (x )
Par récurrence, on peut montrer que :

p
 ai 2 i
y 0  x i 0  xn
Complexité (coût)
Notes :
- les nombres dont la représentation binaire ont exactement p chiffres forment
exactement l’intervalle : [2 p 1 ,2 p  1]
- Nombres de chiffres dans l’écriture binaire de n = 1+[log2 n]. Notons (n) le
nombre de « 1 » dans l’écriture binaire de n.
 Nombre d’opérations effectuées =
 (1+log2 n)-1 élévations au carré (ne pas oublier l’étape 3) ;

 (n)-1 multiplications par x (ne pas oublier l’étape 3).

Soit en tout : T(n) = log2 n+(n)-1 multiplications.
Sachant que : 1 <= (n) <= log2 n  log2 n <=T(n) <= 2log2 n
Pour n = 1000, l’algorithme trivial effectue 999 multiplications, et la méthode binaire
moins de 20.
….. Peut-on mieux faire ?
Prenons le cas n = 15.

1- n = 1111
1 1 1 1
2- SX SX SX SX
3- SX SX SX
4- Nous partons de x et nous obtenons successivement : x2, x3, x6, x7, x14, x15.
Nous sommes donc capables de calculer x15 en 6 multiplications.
Autre schéma de calcul : x2, x3, x6, x12 et faisons x15 = x12 x x3
 Nous obtenons ainsi x15 en 5 multiplications
 la méthode binaire n’est donc pas optimale (c’est-à-dire que l’on peut faire mieux).

4.3 - Algorithme des facteurs
Algorithme
 x si n 1

x   x n 1.x
n
si n premier
( x p ) n ' si n  p.n' avec p le ppdp de n

ppdp : le plus petit diviseur premier
Illustration avec n = 15
1. 15 = 3x5, 3 étant le plus petit diviseur (facteur) premier de 15. Donc x15 = (x3)5.
Nous réappliquons l’algorithme pour calculer x3 et y5, où y = x3.

2. Calcul de x3 :
(a) 3 est premier. Donc x3 = x2 .x
Nous réappliquons l’algorithme pour calculer x2.
(b) 2 est premier. Donc x2 = x.x
(c) Finalement, x3 est calculé comme suit : x3 = x.x.x, soit en deux multiplications.
3. Calcul de y5 :

(a) 5 est premier. Donc y5 = y4.y Nous réappliquons l’algorithme pour calculer
y4.
(b) 4 = 2x2, où 2 est le plus petit facteur premier de 4. Donc y4 = (y2)2.
(c) Finalement y5 est calculé comme suit : t = y.y, u = t.t, y5 = u.y, soit en 3
multiplications.
4. Finalement, x15 est calculé en 5 multiplications.
Peut-on faire mieux ? Oui...  L’algorithme de l’arbre (à découvrir)
 Nous avons affaire à un problème simple, que tout le monde sait résoudre, mais
qu’il est très difficile de résoudre efficacement...

5- Problème_4 : Calcul de la Trans. de Fourier »
Transformée de Fourier 1-D continue (rappel) :
Si f(x) est continue et intégrable, alors la transformée de Fourier continue est définie
par :
 
 2jux 2jux
F(u)  f(x)e

dx et l’inverse f(x)  F(u)e

du
La TF discrète est donnée par :
N 1 N 1 2jux / N
f(x) F(u)e
2 jux / N
F (u )  1 / N  f ( x )e et
x 0 u 0
Données : N échantillons de la fonction f(i), pour i=0,1,…, n
Objectifs : Calculer F(u) pour une valeur de u donnée

5.1 - Algorithme trivial :
pin= 6.28*u/n;
Fu=0
For k = 0 to n do
Fu = Fu + f(k)*exp(-j*pin*k) // opérations complexes
Endfor
- (n+1) additions complexes
- (n+1) multiplications complexes
- (n+1) multiplications réelle
- (n+1) calcul d’une exponentielle

5.2 - Algorithme de Tookey Kooley
On pose : WNux exp(2iux / N) et WN exp(2i / N)
 M 1 M 1
u(2x1) 
 F(u )1/ 2

1/ M 
x0
u(2x)
f(2x)W2M 1/ M 
x0
f(2x1)W2M 

 F(u)1/ 2 Fpaire(u) Fimpaire(u)W2uM 
 Par récursivité, le calcul de la TF se ramène au calcul de la TF de 2 échantillons

Exemple : Fonction à 8 échantillons
f(0) f(4) f(2) f(6) f(1) f(5) f(3) f(7)
TF de 2
points
TF de 4
points
TF de 8 points
 il suffit d’avoir une fonction récursive qui calcule la TF de deux points

On démontre que pour calculer la TF d’une fonction à n échantillons :
T(n) est fonction de nlog2(n) (voir théorème plus loin)
6- Conclusion
- Existence de plusieurs solutions pour un problème donné
- Ces solutions peuvent être correctes mais n’ont pas la même efficacité (coût)
- Avant de proposer un algorithme, il faut estimer son coût
- Et se poser la question de l’existence d’une autre solution moins coûteuse

Chap-2 : Complexité et optimalité
7- Définition de la complexité
7.1 - Définition (Complexité):
La complexité d’un algorithme est la mesure du nombre d’opérations fondamentales

qu’il effectue sur un jeu de données. La complexité est fonction de la taille du jeu de
données.
Nous notons Dn l’ensemble des données de taille n et T(d) le coût de l’algorithme sur
la donnée d.
On définit 3 types de complexité :
- Complexité au meilleur
- Complexité au pire
- Complexité moyenne
7.2 - Complexité au meilleur :

Tmin ( n)  min dDn C (d )
C’est le plus petit nombre d’opérations qu’aura à exécuter l’algorithme sur un jeu de
données de taille fixée, ici à n. C’est une borne inférieure de la complexité de
l’algorithme sur un jeu de données de taille n.
7.3 - Complexité au pire :
Tmax (n)  max dDn C (d )

C’est le plus grand nombre d’opérations qu’aura à exécuter l’algorithme sur un jeu de
données de taille fixée, ici à n.
Avantage : il s’agit d’un maximum, et l’algorithme finira donc toujours avant d’avoir
effectué Tmax(n) opérations.
Inconvénient : cette complexité peut ne pas refléter le comportement « usuel » de
l’algorithme. Le pire cas ne peut se produire que très rarement, mais il n’est pas rare
que le cas moyen soit aussi mauvais que le cas pire.
7.4 - Complexité en moyenne :

 C (d )
d Dn
Tmoy ( n) 
Dn
C’est la moyenne des complexités de l’algorithme sur des jeux de données de taille n
(en toute rigueur, il faut bien évidemment tenir compte de la probabilité d’apparition de
chacun des jeux de données).
Avantage : reflète le comportement « général » de l’algorithme si les cas extrêmes
sont rares ou si la complexité varie peu en fonction des données.
Inconvénient : en pratique, la complexité sur un jeu de données particulier peut être
nettement plus importante que la complexité en moyenne, dans ce cas la complexité
en moyenne ne donnera pas une bonne indication du comportement de l’algorithme.
En pratique, nous ne nous intéresserons qu’à la complexité au pire et à la complexité
en moyenne.
8- Définition de l’optimalité :
Un algorithme est dit optimal si sa complexité est la complexité minimale parmi les
algorithmes de sa classe.

Nous nous intéresserons quasi exclusivement à la complexité en temps des
algorithmes. Il est parfois intéressant de s’intéresser à d’autres ressources, comme la
complexité en espace (taille de l’espace mémoire utilisé), la largeur de bande
passante requise, etc.
9- Illustration : cas du tri par insertion

9.1 - Problématique du tri
Données : une séquence de n nombres, a1, ..., an.

Résultats : une permutation a’i de la séquence d’entrée, telle que a ' i  a ' i 1 i
9.2 - Principe du tri par insertion
De manière répétée, on retire un nombre de la séquence d’entrée et on l’insère à la

bonne place dans la séquence des nombres déjà triés (ce principe est le même que
celui utilisé pour trier une poignée de cartes).
9.3 - Algorithme
For j=2 to n do On retire un nombre de la séquence

clé = A[ j] d’entrée.

i= j-1 Les j-1 premiers éléments de A sont
while (i > 0 and A[i] > clé) do déjà triés.
A[i+1]=A[i] Tant que l’on n’est pas arrivé au début
i=i-1 du tableau, et que l’élément courant
End_while est plus grand que celui à insérer.
A[i+1]=clé On décale l’élément courant (on le
Endfor met dans la place vide).
Finalement, on a trouvé où insérer
notre nombre.
9.4 - Complexité
Attribuons un coût en temps à chaque instruction, et comptons le nombre d’exécutions de

chacune des instructions. Pour chaque valeur de j [2, n] , nous notons tj le nombre
d’exécutions de la boucle « while » pour cette valeur de j. Il est à noter que la valeur de tj
dépend des données...
Instruction Coût Coût total
unitaire
For j=2 to n do c1 n

clé = A[ j ] c2 n-1
i= j-1 c3 n-1
while (i > 0 and A[i] > clé) do c4 n
t
j 2
j
A[i+1]=A[i] c5 n
 (t
j 2
j  1)
i=i-1 c6 n
End_while  (t
j 2
j  1)
A[i+1]=clé c7
Endfor n-1
Le temps d’exécution total de l’algorithme est alors la somme des coûts élémentaires:
n n n
T (n)  c1 n  c 2 (n  1)  c 3 (n  1)  c 4  t j  c 5  (t j 1)  c 6  (t j  1)  c 7 (n  1)
j 2 j 2 j 2
Complexité au meilleur :
le cas le plus favorable pour l’algorithme TRI-INSERTION est quand le tableau est déjà
trié. Dans ce cas tj = 1 pour tout j.

T(n) = c1n+c2(n-1)+c3(n-1)+c4(n-1)+c7(n-1)
= (c1+c2+c3+c4+c7)n-(c2+c3+c4+c7):
T(n) peut ici être écrit sous la forme T(n) = an+b, a et b étant des constantes indépendantes
des entrées, et
 T(n) est donc une fonction linéaire de n.
Le plus souvent, comme c’est le cas ici, le temps d’exécution d’un algorithme est fixé pour une
entrée donnée; mais il existe des algorithmes « aléatoires » intéressants dont le comportement
peut varier même pour une entrée fixée.
Complexité au pire :
Le cas le plus défavorable pour l’algorithme TRI-INSERTION est quand le tableau est déjà trié
dans l’ordre inverse. Dans ce cas tj = j pour tout j.
n(n  1) n(n  1) n( n  1)
  
n n n
Rappel : j 1
j donc j 2
j 1 et j 2
( j  1) 
2 2 2
n(n  1) n(n  1) n(n  1)

T (n)  c1 n  c 2 (n  1)  c 3 (n  1)  c 4 (  1)  c 5 ( )  c6 ( )  c 7 (n  1)
2 2 2
1 1
T ( n)  (c 4  c 5  c 6 )n 2  (2c1  2c 2  2c 3  c 4  c 5  c 6  c 7 )n  (c 2  c 3  c 4  c 7 )
2 2
T(n) est donc de la forme T (n)  an 2  bn  c

T(n) est donc une fonction quadratique de n.

Complexité en moyenne :
Supposons que l’on applique l’algorithme de tri par insertion à n nombres choisis au
hasard. Quelle sera la valeur de tj ? C’est-à-dire, où devra-t-on insérer A[ j] dans le
sous-tableau A[1.. j-1] ?
En moyenne, la moitié des éléments de A[1.. j-1] sont inférieurs à A[ j], et l’autre moitié
sont supérieurs. Donc t j = j/2. Si l’on reporte cette valeur dans l’équation définissant
T(n), on obtient, comme dans le cas pire, une fonction quadratique en n.
Ordre de grandeur :
Ce qui nous intéresse vraiment, c’est l’ordre de grandeur du temps d’exécution. Seul le
terme dominant de la formule exprimant la complexité nous importe, les termes
d’ordres inférieurs n’étant pas significatifs quand n devient grand. On ignore également
le coefficient multiplicateur constant du terme dominant. On écrira donc, à propos de la
complexité du tri par insertion :
Complexité au meilleur = (n).
Complexité au pire = (n2).
Complexité en moyenne = (n2).

En général, on considère qu’un algorithme est plus efficace qu’un autre si sa
complexité dans le cas pire a un ordre de grandeur inférieur.
Classes de complexité
Les algorithmes usuels peuvent être classés en un certain nombre de grandes classes
de complexité :
1. O(logn) : Les algorithmes sub-linéaires dont la complexité est en général en
O(logn).
2. O(n) : Les algorithmes linéaires en complexité O(n)
3. O(nlogn) : et ceux en complexité en O(nlogn)
4. O(nk) : Les algorithmes polynomiaux en O(nk) pour k > 3
5. Exp(n) : Les algorithmes exponentiels
Les trois premières classes sont considérées rapides alors que la quatrième est
considérée lente et la cinquième classe est considérée impraticable.

log2(n) n nlog2(n) n2 n3 n4 exp(n)
1 0,00 1 0,00 1 1 1 3
2 1,00 2 2,00 4 8 16 7
3 1,58 3 4,75 9 27 81 20
4 2,00 4 8,00 16 64 256 55
5 2,32 5 11,61 25 125 625 148
6 2,58 6 15,51 36 216 1296 403
7 2,81 7 19,65 49 343 2401 1097
8 3,00 8 24,00 64 512 4096 2981
9 3,17 9 28,53 81 729 6561 8103
10 3,32 10 33,22 100 1000 10000 22026
11 3,46 11 38,05 121 1331 14641 59874
12 3,58 12 43,02 144 1728 20736 162755
13 3,70 13 48,11 169 2197 28561 442413
14 3,81 14 53,30 196 2744 38416 1202604
15 3,91 15 58,60 225 3375 50625 3269017
16 4,00 16 64,00 256 4096 65536 8886111
17 4,09 17 69,49 289 4913 83521 24154953
18 4,17 18 75,06 324 5832 104976 65659969

19 4,25 19 80,71 361 6859 130321 178482301
20 4,32 20 86,44 400 8000 160000 485165195
Exponentielle an
n3
n2 Quadratique
T(n)
n.Log(n)
Log(n)

Chap-3 : La Récursivité, Souplesse et Complexité
10- Récursivité
De l’art et la manière d’élaborer des algorithmes pour résoudre des problèmes qu’on
ne sait pas résoudre soi-même !
10.1 -Définition
Une définition récursive est une définition dans laquelle intervient ce que l’on veut
définir.
Un algorithme est dit récursif lorsqu’il est défini en fonction de lui-même.

10.2 -Récursivité simple
Revenons à la fonction puissance x xn. Cette fonction peut être définie

récursivement :
 1 si n0
x n   n 1
 x.x si n 1
L’algorithme correspondant s’écrit :
Puissance (x, n)
Begin
If (n = 0) then
return 1
Else
return (x*Puissance (x, n-1))
End

10.3 -Récursivité multiple
Une définition récursive peut contenir plus d’un appel récursif.

Exemple_1 : Nombre de Combinaisons
On se propose de calculer le nombre de combinaisons C np en se servant de la relation
de Pascal :
 1 si p  0 ou pn
C np   p p 1
C n 1  C n 1 sin on
L’algorithme correspondant s’écrit :
Combinaison (n, p)
Begin
If ( p = 0 OR p = n) then
return 1
Else
return (Combinaison (n-1, p) + Combinaison (n-1, p-1))
End

Exemple_2 : Suite de Fibonacci
Fibonacci ( n)
If ( n=0 or n =1 )
Return 1
Else
Return (Fibonacci (n-2) + Fibonacci (n-1) )
End_Fibonacci

10.4 -Récursivité mutuelle
Des définitions sont dites mutuellement récursives si elles dépendent les unes des
autres. Ça peut être le cas pour la définition de la parité :
 vrai si n0  faux si n0
pair ( n)   et impair (n)  
impair (n  1) sin on  pair (n  1) sin on
Les algorithmes correspondants s’écrivent :
Pair (n) Impair (n)

Begin Begin
If ( n = 0 ) Then If ( n = 0 ) Then
return (vrai) return (faux)
Else Else
return (impair(n-1) ) return ( Pair (n-1))
End End

10.5 -Récursivité imbriquée
La fonction d’Ackermann est définie comme suit :

 n 1 si m0

A( m, n)   A(m  1,1) si m0 et n0
 A( m  1, A( m, n  1)) sin on

d’où l’algorithme :
Ackermann (m, n)
Begin
If ( m = 0 ) Then
return (n+1)
else
If (n=0) Then
Return(Ackermann (m-1, 1))
else
Return ( Ackermann (m-1, Ackermann (m, n-1)) )
End

10.6 -Principe et dangers de la récursivité
Principe et intérêt :
Ce sont les mêmes que ceux de la démonstration par récurrence en mathématiques.

On doit avoir :
- un certain nombre de cas dont la résolution est connue, ces «cas simples»
formeront les cas d’arrêt de la récursivité
- un moyen de se ramener d’un cas « compliqué » à un cas «plus simple».
La récursivité permet d’écrire des algorithmes concis et élégants.
Difficultés :
– la définition peut être dénuée de sens :

Algorithme A(n)
renvoyer A(n)
– il faut être sûr qu’on retombera toujours sur un cas connu, c’est-à-dire sur un cas
d’arrêt ; il nous faut nous assurer que la fonction est complètement définie, c’est-à-
dire, qu’elle est définie sur tout son domaine d’applications.

Moyen : existence d’un ordre strict tel que la suite des valeurs successives des
arguments invoqués par la définition soit strictement monotone et finit toujours par
atteindre une valeur pour laquelle la solution est explicitement définie.
Exemple : L’algorithme ci-dessous teste si a est un diviseur de b.
Diviseur (a,b)
If (a <=0) then Erreur
Else
If (a>=b) return (a=b)
Else
Return (Diviseur (a,b-a) )
End_Diviseur
La suite des valeurs b, b-a, b-2a, etc. est strictement décroissante, car a est
strictement positif, et on finit toujours par aboutir à un couple d’arguments (a,b) tel que
b-a est négatif, cas défini explicitement.

10.7 -Importance de l’ordre des appels récursifs
Fonction qui affiche les entiers par ordre décroissant, de n jusqu’à 1 :
Décroissant (n) Croissant (n)

If (n = 0 )Then ne rien faire If ( n = 0) Then ne rien faire
Else Else
afficher n Croissant (n-1)
Décroissant (n-1) afficher n
End_if Endif
End_Décroissant End_Croissant
Décroissant(2)  affiche :2 suivi de 1 Croissant(2)  affiche : 1 suivi de 2

10.8 -Exemple d’algorithme récursif : les tours de Hanoï
Le problème
Le jeu est constitué d’une plaquette de bois où sont plantées trois tiges numérotées 1,
2 et 3. Sur ces tiges sont empilés des disques de diamètres tous différents. Les seules
règles du jeu sont que l’on ne peut déplacer qu’un seul disque à la fois, et qu’il est
interdit de poser un disque sur un disque plus petit.
Au début, tous les disques sont sur la tige 1 (celle de gauche), et à la fin ils doivent
être sur celle de droite.
Résolution :
Principe : On suppose que l’on sait résoudre le

problème pour (n-1) disques. Pour déplacer n disques de la
tige 1 vers la tige 3, on déplace les (n-1) plus petits disques
de la tige 1 vers la tige 2, puis on déplace le plus gros disque
de la tige 1 vers la tige 3, puis on déplace les (n-1) plus petits
disques de la tige 2 vers la tige 3.

Validité : il n’y a pas de viol des règles possible puisque le plus gros disque est
toujours en « bas » d’une tige et que l’hypothèse (de récurrence) nous assure que
nous savons déplacer le « bloc » de (n-1) disques en respectant les règles.
Algorithme
Hanoi (n, départ, intermédiaire, destination)

If n > 0 Then
Hanoi (n-1, départ, destination, intermédiaire)
déplacer un disque de départ vers destination
Hanoi (n-1, intermédiaire, départ, destination)
Endif
End_Hanoi
L’appel à Hanoi(3,1,2,3) entraîne l’affichage de :

1. Déplace un disque de la tige 1 vers la tige 3

7. Déplace un disque de la tige 1 vers la tige 3 ..\Exemples\Hanoi.cpp
Complexité
On compte le nombre de déplacements de disques effectués par l’algorithme Hanoi

invoqué sur n disques.
 1 si n 1  1 si n 1
C ( n)   
C (n  1)  1  C (n  1) sin on 1  2C (n  1) sin on
Et on en déduit facilement (démonstration par récurrence) que :
C ( n)  2 n  1
On a donc ici un algorithme de complexité exponentielle.
En supposant que le déplacement d’un disque nécessite 1minute (il faut réfléchir et
déplacer un disque qui peut être lourd puisqu’il est en or), et si on dispose de 64
disques, il faudrait :
C ( n)  2 64  1 minutes = 3,50965 1013 = 35096,5 milliards d'années

11- Dérécursivation
Dérécursiver, c’est transformer un algorithme récursif en un algorithme équivalent ne
contenant pas d’appels récursifs.
11.1 -Récursivité terminale
Définition (Récursivité terminale) :
Un algorithme est dit récursif terminal s’il ne contient aucun traitement après un appel
récursif.
Exemple :
Algorithme P(U) – U est la liste des paramètres ;
If ( Condition(U) ) Then – C est une condition portant sur U ;
Traitement_base (U); – (U) représente la transformation
P((U)) ; des paramètres ;
Else
Traitement_terminaison(U)
;
Endif
End_Algorithme

Algorithme dérécursivée :
Algorithme P’(U)
While ( Condition(U) ) do
Traitement_base(U);
U (U)
End_while
Traitement_terminaison;
End_Algorithme
L’algorithme P’ non récursif équivaut à l’algorithme P.

Remarquer la présence d’une boucle.

Exemple_1 : Est-ce que a est diviseur de b ?
Version récursive Version dérécursivée

Diviseur (a,b)
?
If (a <=0) then Erreur
Else
If (a>=b) return (a=b)
Else
Return (Diviseur (a,b-a) )
End_Diviseur

Exemple_1 : Est-ce que a est diviseur de b ?

Diviseur (a,b) Diviseur(a,b)
If (a <=0) then Erreur If (a <= 0 )then Erreur
Else While ( b > a )
If (a>=b) return (a=b) b=b-a
Else
Return (Diviseur (a,b-a) ) return (a=b)
End_Diviseur End_Diviseur

Exemple_2 : Factoriel (N) ?

Factoriel(N)
?
If ( N = 0)
Return 1 ;
Else
Return N*Factoriel (N-1) ;
End_Factoriel

Exemple_2 : Factoriel (N) ?

Factoriel(N) Factoriel (N)
If ( N = 0) F=1;
Return 1 ; For i=N step -1 to 1 do
Else F=F*i
Return N*Factoriel (N-1) ;
End_Factoriel End_Factoriel

Récursivité non terminale
Dans l’algorithme suivant la récursivité n’est pas terminale puisque l’appel récursif est
suivi d’un traitement. Cela implique qu’il reste un traitement à reprendre
ultérieurement. Il va falloir donc sauvegarder, sur une pile, le contexte de l’appel
récursif, typiquement les paramètres de l’appel engendrant l’appel récursif.
Algorithme récursif :
Algorithme Q(U)
If ( Condition(U) ) Then
Traitement_A(U);
Q((U));
Traitement_B(U)
Else
Traitement_terminaison(U)
Endif
End_Algorithme

Algorithme dérécursivé :
Algorithme Q’(U)
Pile.init() ;
While (Condition (U)) do
Traitement_A(U) ;
Pile.push(U) ;
U= (U);
Endwhile
Traitement_terminaison (U) ;
While (not Pile.empty()) do
Pile.pop (U) ;
Traitement_B(U) ;
Endwhile
End_Algo

Exemple_3 :

void recursif(int n) void recursif(int n)
{ Pile.init() ;
if ( n> 0) While ( )do
{
cout<<"\nIN : N = "<<n<< endl ;
recursif(n-1); Pile.push(U) ;
cout << "\nOUT : N = "<<n<<endl;
} Endwhile
else
cout << "\nTerminaison"<<endl;
}
While (not Pile.empty()) do
Pile.pop (U) ;
Endwhile
End_Algo

..\Exemples\Derecursive.cpp

11.2 -Remarques
Les programmes itératifs sont souvent plus efficaces, mais les programmes récursifs
sont plus faciles à écrire.
Il est toujours possible de dérécursiver un algorithme récursif.

12- Diviser pour régner
12.1 -Principe
De nombreux algorithmes ont une structure récursive: pour résoudre un problème

donné, ils s’appellent eux-mêmes récursivement une ou plusieurs fois sur des
problèmes très similaires, mais de tailles moindres, résolvent les sous problèmes de
manière récursive puis combinent les résultats pour trouver une solution au problème
initial.
Le paradigme « diviser pour régner » donne lieu à trois étapes à chaque niveau de
récursivité :
Diviser le problème en un certain nombre de sous-problèmes ;
Régner sur les sous-problèmes en les résolvant récursivement ou, si la taille d’un
sous-problème est assez réduite, le résoudre directement ;
Combiner les solutions des sous-problèmes en une solution complète du problème
initial.

12.2 -Exemple_1 : Recherche du maximum d’un tableau
maximum ( x , left, right) problème

if ( left = right)
return left;
else
m=(left+right)/2 // Sous-problème1 Sous-problème2 division
du problème en 2 sous-
problèmes
k1 = maximum (x, left, m ) // régner sur le 1er sous-problème
k2 = maximum (x, m+1, right)// régner sur le 2ème sous-problème
if(x(k1) > x(k2)) // combiner les solutions
return k1
else
return k2
End_maximum

12.3 -Eexemple_2 : multiplication naïve de matrices
Nous nous intéressons ici à la multiplication de matrices carrées de taille n.
Algorithme naïf
L’algorithme classique est le suivant :

Soit n la taille des matrices carrés A et B
Soit C une matrice carrée de taille n
Multiplier (A, B,C)
For i = 1 to n do
For j=1 to n do
C(i,j)=0
For k=1 to n do
C(i,j)= C(i,j) +A(i,k)*B(k,j)
End_Multiplier
Cet algorithme effectue (n3) multiplications et autant d’additions.

Algorithme « diviser pour régner » naïf
Dans la suite nous supposerons que n est une puissance de 2. Décomposons les
matrices A, B et C en sous-matrices de taille n/2 x n/2. L’équation C = AB peut alors
se récrire :
r s a b  e g
  * 
t u   c d   f h 
En développant cette équation, nous obtenons :
r = ae+bf ; s = ag+bh; t = ce+df et u = cg+dh:
Chacune de ces quatre opérations correspond à :

- deux multiplications de matrices carrées de taille n/2  2T(n/2)
- et une addition de telles matrices  O(n2)
A partir de ces équations on peut aisément dériver un algorithme « diviser pour régner
» dont la complexité est donnée par la récurrence :
T(n) = 8T(n/2)+(n2)

12.4 -Analyse des algorithmes « diviser pour régner »
Lorsqu’un algorithme contient un appel récursif à lui-même, son temps d’exécution

peut souvent être décrit par une équation de récurrence qui décrit le temps d’exécution
global pour un problème de taille n en fonction du temps d’exécution pour des entrées
de taille moindre.
La récurrence définissant le temps d’exécution d’un algorithme « diviser pour régner »
se décompose suivant les trois étapes du paradigme de base :
1. Si la taille du problème est suffisamment réduite, n <= c pour une certaine constante
c, la résolution est directe et consomme un temps constant (1).
2. Sinon, on divise le problème en a sous-problèmes chacun de taille 1/b de la taille du
problème initial. Le temps d’exécution total se décompose alors en trois parties :
- D(n) : le temps nécessaire à la division du problème en sous-problèmes.
- aT(n/b) : le temps de résolution des a sous-problèmes.
- C(n) : le temps nécessaire pour construire la solution finale à partir des solutions
aux sous-problèmes.
La relation de récurrence prend alors la forme :

 (1) si nc
T ( n)  
aT ( n / b)  D( n)  C (n) sin on

Notations de Landau
Quand nous calculerons la complexité d’un algorithme, nous ne calculerons
généralement pas sa complexité exacte, mais son ordre de grandeur. Pour ce faire,
nous avons besoin de notations asymptotiques connues sous le nom de « notation de
Landau » (Mathématicien Allemand ) :
: f  ( g )  n0, c  0, / n  n0, f (n)  c.g (n)

On dit aussi que f « est dominée asymptotiquement par g »
Ou que g « est un majorant presque partout de f »
Exemples :
n = O(n), 2n = O(3n), n+2 = O(n) (Il suffit de prendre n0 = 2 et c = 2)
sqrt(n) = O(n), log(n) = O(n), n = O(n2).
: f  ( g )  g  ( f )
Cela signifie que g « est majorée par f »
o: f  o( g )  c  0, n0 / n  n0, f ( n)  c.g ( n)

Ceci signifie que : f « est négligeable devant g »
Exemples : sqrt(n) = o(n), log(n) = o(n), n = o(n2), log(n) = o(sqrt(n)).

: f  ( g )  f  ( g ) et g  ( f )
Ceci signifie que :
f  ( g )  c, d  R  , n0 / n  n0 d .g (n)  f (n)  c.g (n)
Ce qui veut dire que chaque fonction est un majorant de l’autre ou encore
que les deux fonctions sont « de même ordre de grandeur asymptotique »
Exemples : n+log(n) = (n+sqrt(n)).
Remarques :
On peut considérer que :
(g ) est une borne supérieure
(g ) est une borne inférieure
(g ) est une borne exacte. Celle-ci est donc plus précise que les précédentes

Résolution des récurrences
12.5 -Équations de récurrence linéaires
Exemple : La suite de Fibonacci est définie par :

 1 si n2
un  
u n1  u n2 sin on
Un algorithme récursif pour calculer le nème terme de la suite est :
Fibonacci ( n)
If ( n=0 or n =1 )
Return 1
Else
Return (Fibonacci (n-2) + Fibonacci (n-1))
End_Fibonacci
Soit T(n) le nombre d’additions effectuées par cet algorithme. T(n) vérifie les équations
suivantes :

 0 si n  0

T ( n)   0 si n  1
1  T (n  1)  T (n  2) si n  2

Cette équation est linéaire et d’ordre 2 car chaque terme de rang >1 dépend
uniquement des deux termes qui le précèdent.
Définition : Une équation récurrente est dite linéaire d’ordre k si chaque terme
s’exprime comme combinaison linéaire des k termes qui le précèdent plus une
certaine fonction de n.
u n  1 .u n1   2 .u n2  ...   k .u nk  f (n)
Il faut bien sûr connaître les k premiers termes.
A l’ordre 1, l’équation devient :
u n  a.u n1  f (n)
Par itération et sommation on trouve :
n
f (i )
u n  a (u 0  
n
)
i 1 ai

Exemple : Problème des tours de Hanoi
Le coût de l’algorithme récursif est :
 0 si n0
T ( n)   T(n) est donc de la forme : u n  2.u n1  1
2T (n  1)  1 si n 1
Cette équation peut être résolue par la méthode itérative :
u n  2.u n1  1
un  2(2un2  1)  1  2 2 un2  2  1  2 2 u n3  2 2  2  1
……
n 1
u n  2 n u 0  2 n1  ...  2 2  2  1   2 i  2 n  1
i 0
Si on reprend la formule :
n
f (i )
u n  a (u 0  
n
) et on remplace a par 2 et f(i) par 1 on trouve le même résultat (car
i 1 ai
la somme d’une suite géométrique=u0(qn-1)/(q-1) )
n n
1 1
u n  2 n (u 0   i
)  2 n
(  i
 1)  2 n  1
i 1 2 i 0 2

12.6 -Equation de récurrence linéaire sans second membre
Une équation de récurrence est dite sans second membre si f(n)=0

u n   1 .u n 1   2 .u n  2  ...   k .u n  k  0
A une telle équation, on peut associer un polynôme caractéristique :
P ( x)  x k   1 x k 1   2 x k  2  ...   k
La résolution de ce polynôme nous donne m racines r i ( avec m<=k).
La solution de l’équation de récurrence est ainsi donnée par :

u n  Q1 (n)r1n  Q2 (n)r2n  ...  Qm (n)rmn
Cette solution est en général exponentielle.

Exemple :
Reprenons l’exemple de la suite de Fibonacci. Son coût est donné par :
 0 si n  0

T ( n)   0 si n  1
1  T (n  1)  T (n  2) si n  2

En posant : S ( n)  T ( n)  1 on obtient :
 1 si n0

S ( n)   1 si n 1
S (n  1)  S ( n  2) si n2

Donc une équation de récurrence sans second membre.
S ( n)  S (n  1)  S (n  2)  0
Son polynôme caractéristique est : x 2  x  1  0
1 5 1 5
Il possède deux racines : et
2 2
La solution de l’équation de récurrence est donc :
n n
 1 5  1 5 
S ( n)  a   b
  2 

 2   
Les coefficients a et b peuvent être déterminés à l’aide des conditions aux limites :

S ( 0)  1  a  b
a  b (a  b) 5
S (1)  1  
2 2
d’où :
5 5 5 5
a et b
10 10
et enfin :
n n
5  5 1 5  5  5 1 5 
S ( n)      

10  2   10  2 
Donc :
  1  5 n 
S (n)  T (n)     
 
 2
  
Exemple-2 :
Soit la suite définie par :
un  3un1  4un2 si n  2

 u0  0 et u1  1
Son polynôme caractéristique est :
P( x)  x 2  3 x  4
Ses racines sont : r1  4 et r2  1
La solution de l’équation de récurrence est donc :

u n  a 4 n  b(1) n
Les conditions aux limites donnent :
u( )0  a  b  0  1 1
   a  et b  
u(1)  4a b 1  5 5
1 n
d’où : u ( n)  (4  (1) n )  (4 n )
5

12.7 -Résolution des récurrences « diviser pour régner »
Théorème 1 (Résolution des récurrences « diviser pour régner »).
Soient a >=1 et b > 1 deux constantes, soit f (n) une fonction et soit T(n) une
fonction définie pour les entiers positifs par la récurrence :
T ( n)  a.T (n / b)  f (n)
T(n) peut alors être bornée asymptotiquement comme suit :
Si la forme de f(n) est : Alors le coût est :
(log a ) 
1 f ( n)  ( n b
) pour un > 0 T (n)  (n log a ) b
2 f (n)  (n logb a ) T (n)  (n logb a log n)

3 f ( n)  ( n (logb a ) ) pour un > 0, T (n)  ( f ( n))
et af (n / b)  cf (n)
pour un c < 1 et n suffisamment grand

Version-2 du théorème
T (n)  a.T (n / b)  f ( n) ou T ( n)  a.T ( n / b)  c.n k
Si on a : Alors le coût est :

1 ab k
T (n)  (n log b a )
2 a  bk T (n)  (n k log n)
3 a  bk T ( n )  ( n k )
Signification intuitive du théorème :

Dans chaque cas, on compare f (n) avec n log a . La solution de la récurrence est
b
déterminée par la plus grande des deux.
Exemple-1 : Retour sur l’exemple de la multiplication de matrices :
La relation de récurrence est : T(n) = 8T(n/2)+(n2)
Donc : a = 8,
b = 2  logb a = 3

f (n) = (n2) = (n log a-1) b
On est donc dans le cas 1 du théorème (avec = 1), l’algorithme a donc une
complexité en (n3)
Exemple-2 :
n
T (n)  9T    n
3
On est dans le cas : a=9 , b=3 et f(n)=n
9 
 n log a  n log 9  n 2  (n 2 )  f (n)  n  n 21  n log
b 3 3
avec   1
 On applique le cas 1 : T (n)  (n 2 )

Exemple-3 :
 2n 
T ( n)  T   1
 3 
On est dans le cas : a=1 , b=3/2 et f(n)=1
log 1
 1  f (n)  (n
log a
 n log a  n )
3 b
b 2
On applique donc le cas 2 :

T (n)  (nlog b a. log n)  (log n)

Exemple-4 :
n
T (n)  3T    n log n
4
On est dans le cas : a=3 , b=4 et f(n)=nlogn
 n log a  n log 3  (n 0,793 )  f (n)  (n log 3 ) avec   0.2
b 4 4
Pour n suffisamment grand on a :

n n n 3 3
af    3 log   n log n  c. f (n) avec c
4 4 4 4 4
On applique donc le cas 3 :

T ( n)  ( n log n)

12.8 -Autres récurrences :
D’autres récurrences peuvent ne pas trouver de solution avec les techniques

présentées. Dans ce cas, on peut procéder par itération :
- calculer les quelques premières valeurs de la suite
- chercher une régularité
- poser une solution générale en hypothèse
- la prouver par induction

13- Pourquoi estimer la complexité d’un algorithme ?
Considérons l’exemple de la suite de Fibonacci, et écrivons deux programmes
différents : un récursif et l’autre non récursif.
Fibonacci récursif Fibonacci non récursif

int fibo (int n) int fibo (int n)
{ { int k,i,f1,f2;
if (n<2) i=1;
return 1; if (n < 2)
else return i;
return( fibo(n-1)+fibo(n-2)); f1=f2=1;
} for (k=2; k<= n ; k++)
{ i=f1+f2; f1=f2; f2=i; }
}
T(n)=O(an)  exponentielle T(n)= O(n)

Si on suppose qu’une opération d’addition nécessite 100ns, alors, pour calculer
Fibo(n), on obtient les résultats suivants :
Nb-additions Nb-Secondes
Non Non
n Récursif Récursif Récursif Récursif Récursif
20 19 10945 0,0000019 0,0010945 2*10-5 mn
30 29 1346260 0,0000029 0,134626 2*10-3 mn
40 39 165580140 0,0000039 16,558014 3*10-1 mn
50 49 3185141889 0,0000049 318,514189 5 mn
100 500 000 années

Coût théorique = (1+sqrt(5)/2)n
n Cout sec min h jour an
10 122,991869 1,23E-05 2,05E-07 3,42E-09 1,42E-10 3,90E-13
20 15126,9999 1,51E-03 2,52E-05 4,20E-07 1,75E-08 4,80E-11
30 1860498 1,86E-01 3,10E-03 5,17E-05 2,15E-06 5,90E-09
40 228826127 2,29E+01 3,81E-01 6,36E-03 2,65E-04 7,26E-07
50 2,8144E+10 2,81E+03 4,69E+01 7,82E-01 3,26E-02 8,92E-05
60 3,4615E+12 3,46E+05 5,77E+03 9,62E+01 4,01E+00 1,10E-02
70 4,2573E+14 4,26E+07 7,10E+05 1,18E+04 4,93E+02 1,35E+00
80 5,2361E+16 5,24E+09 8,73E+07 1,45E+06 6,06E+04 1,66E+02
90 6,44E+18 6,44E+11 1,07E+10 1,79E+08 7,45E+06 2,04E+04
100 7,9207E+20 7,92E+13 1,32E+12 2,20E+10 9,17E+08 2,51E+06
..\Exemples\Fibonacci.cpp
 il ne faut pas toujours utiliser la récursivité

 il faut estimer la complexité de son algorithme

Chap-4 : Algorithmes de Tri
14- Tri par sélection

Principe :
Le tri par sélection est basé sur l’idée suivante : Sélectionner le minimum ou le
maximum et le déplacer au début ou à la fin du tableau.
Algorithme :
For I := 1 To N-1 Do
K := I
For J = I+1 To N Do
If ( A(j) < A(k)) Then
K := J
Endif
Endfor
Y := A(I) ; A(I) := A(k) ; A(k) := Y
Endfor
 Quelle est la complexité de cet algorithme ?

15- Tri par insertion linéaire
Principe :
Le tri par insertion est basé sur les principes suivants : dans le tableau à insérer, on
suppose qu’une partie a été triée et qu’il reste à trier l’autre partie. La partie triée est
appelée ‘séquence destination’ et la partie qui reste à trier est appelée ‘séquence
source’
a1 , a2 , a3 , ….. ai-1 , ai, ai+1,….. an
séquence destination séquence source
( triée) ( non triée)
Algorithme :
For I := 2 To N Do
X := A(I) ; J := I
While ( X < A (j-1) and j > 1) Do
A(j) := A(j-1) ; j := J-1
Endwhile
A(j) := X
Endfor Quelle est la complexité de cet algorithme ?

16- Tri par insertion binaire
Principe :
La séquence destination étant ordonnée, nous pouvons donc appliquer une recherche
binaire (voir chapitre ‘problèmes de recherche’) ce qui accélèrera la recherche.
Algorithme :
For I := 2 To N Do
X := A(I)
k=Recherche_Binaire( A , I-1, X)
Decaler_Droite( A , k, I-1)
A (k) := X
Endfor
Quelle est la complexité de cet algorithme ?

17- Tri à bulles
Principe :
Cette méthode est basée sur l’idée de comparer toute paire d’éléments adjacents et
de les permuter s’ils ne sont pas dans le même ordre et répéter le processus jusqu’à
ce qu’il n’y ait plus de permutations.
Algorithme :
Repeat
No_permutation := True
For I := 1 To N-1 Do
If (A(I) > A (I+1)) Then
X :=A(I) ; A(I) := A(I+1) ; A(I+1) := X
No_Permutation := False
Endif
Endfor
Until ( No_permutation)

18- Tri arborescent
Principe :
La méthode du tri arborescent veut mémoriser toute information obtenue à l’issu des
comparaisons pour l’exploiter dans l’établissement de l’ordre final. Pour ce faire elle
construit une arborescence qui traduit la relation qui existe entre tous les éléments.
Considérons l’exemple suivant : Soit le tableau suivant à ordonner :
44 55 12 42 94 18 6 67
6
Quelle est la complexité de cet
algorithme ? 12 6
44 12 18 6
44 55 12 42 94 18 6 67

19- Tri par fusion
19.1 -Principe
L’algorithme de tri par fusion est construit suivant le paradigme « diviser pour régner
»:
1. Il divise la séquence de n nombres à trier en deux sous-séquences de taille n/2.

2. Il trie récursivement les deux sous-séquences.
3. Il fusionne les deux sous-séquences triées pour produire la séquence complète
triée.
La récurrence se termine quand la sous-séquence à trier est de longueur 1

19.2 -Algorithme
La principale action de l’algorithme du tri par fusion est justement la fusion des deux
listes triées.
La fusion
Le principe de cette fusion est simple: à chaque étape, on compare les éléments
minimaux des deux sous-listes triées, le plus petit des deux étant l’élément minimal de
l’ensemble on le met de côté et on recommence. On conçoit ainsi un algorithme
« Fusionner » qui prend en entrée un tableau A et trois entiers, p, q et r, tels que p<=q
< r et tels que les tableaux A[p..q] et A[q+1..r] sont triés.
Le tri
Fusionner (A, p, q, r) // Fusionner les 2 sous-tableaux A(pq) et A(q+1r)
i=p // les 2 sous tableaux sont supposés triés
j=q+1 ; k=1
while (i<=q et j<=r ) do
if ( A[i] < A[ j] ) then
C[k] = A[i] ; i=i+1
else
C[k]=A[ j] ; j=j+1
endif

k=k+1
Endwhile
While i<=q do
C[k]=A[i] ; i=i+1 ; k=k+1
Endwhile
While j<=r do
C[k]=A[j] ; j=j+1 ; k=k+1
Endwhile
For k=1 to r-p+1 do // Recopier le tableau C dans le tableau original
A(p+k-1)= C(k)
Endfor
EndFusionner
Tri_Fusion(A, p, r)
If (p<r ) then
q= (p+r)/2
Tri_Fusion(A, p, q)
Tri_Fusion(A,q+1,r)
Fusionner(A,p,q,r)
Endif

End_Tri_Fusion
Complexité de la fusion
Étudions les différentes étapes de l’algorithme :
– les initialisations ont un coût constant (1) ;
– la boucle While de fusion s’exécute au plus r-p fois, chacune de ses itérations étant
de coût constant, d’où un coût total en O(r-p) ;
– les deux boucles While complétant C ont une complexité respective au pire de q-
p+1 et de r-q, ces deux complexités étant en O(r-p) ;
– la recopie finale coûte (r-p+1).
Par conséquent, l’algorithme de fusion a une complexité en (r-p).

Complexité de l’algorithme de tri par fusion
l’algorithme Tri_Fusion est de type « diviser pour régner ». Il faut donc étudier ses trois
phases:
Diviser : cette étape se réduit au calcul du milieu de l’intervalle [p,r], sa complexité est
donc en (1).
Régner : l’algorithme résout récursivement deux sous-problèmes de tailles respectives
(n/2) , d’où une complexité en 2T(n/2).
Combiner : la complexité de cette étape est celle de l’algorithme de fusion qui est de
(n) pour la construction d’un tableau solution de taille n.
Par conséquent, la complexité du tri par fusion est donnée par la récurrence :
 (1) si n 1
T ( n)  
2T ( n / 2)  (n) sin on
Pour déterminer la complexité du tri par fusion, nous utilisons le théorème de
résolution des récurrences avec : a = 2 et b = 2, donc logb a = 1 et nous nous
trouvons dans le deuxième cas du théorème : f (n) = (nlogb a) = (n). Par conséquent
:
T ( n)  ( n log n)
Pour des valeurs de n suffisamment grandes, le tri par fusion avec son temps
d’exécution en (nlogn) est nettement plus efficace que le tri par insertion dont le
temps d’exécution est en (n2).

20- Tri rapide (Quicksort)
20.1 -Principe
Le tri rapide est fondé sur le paradigme « diviser pour régner », tout comme le tri
fusion, il se décompose donc en trois étapes :
Diviser : Le tableau A[p..r] est partitionné (et réarrangé) en deux sous-tableaux non
vides, A[p..q] et A[q+1..r] tels que chaque élément de A[p..q] soit inférieur ou égal à
chaque élément de A[q+1..r].
L’indice q est calculé pendant la procédure de partitionnement.
Régner : Les deux sous-tableaux A[p..q] et A[q+1..r] sont triés par des appels
récursifs.
Combiner : Comme les sous-tableaux sont triés sur place, aucun travail n’est
nécessaire pour les recombiner, le tableau A[p..r] est déjà trié !
20.2 -Algorithme
Tri_Rapide (A, p, r)
If (p < r ) then

q =Partionner (A, p, r)
Tri_Rapide(A, p, q)
Tri_Rapide (A, q+1, r)
Endif
End_Tri_Rapide
Partionner (A, p, r)
x = A(p)
i = p-1
j= r+1
while (1)
repeat { j=j-1 } until A(j) <= x
repeat { i =i+1 } until A(i) >= x
if ( i < j )
permuter (A(i), A(j))
else return j
End_Partionner

20.3 -Complexité
Pire cas
Le cas pire intervient quand le partitionnement produit une région à n-1 éléments et
une à 1 élément.
Comme le partitionnement coûte (n) et que T(1) = (1), la récurrence pour le temps
d’exécution est :
T (n)  T (n  1)  (n)
et par sommation on obtient :
n n
T ( n )   ( k )   (  k )   ( n 2 )
k 1 k 1
Meilleur cas :
Le meilleur cas intervient quand le partitionnement produit deux régions de longueur
n/2.
La récurrence est alors définie par :
T (n)  2T (n / 2)  (n)
ce qui donne d’après le théorème de résolution des récurrences :
T ( n)  ( n log n)

Complexité moyenne :
Pour avoir une complexité moyenne, on tire au hasard l’indice de départ de
partitionnement. Et on démontre que la complexité moyenne est aussi égale à :
T ( n)  ( n log n)

Chap-5 : Graphes et Arbres
21- Graphes
Un graphe orienté G est représenté par un couple (S, A) où S est un ensemble fini et
A une relation binaire sur S. L’ensemble S est l’ensemble des sommets de G et A est
l’ensemble des arcs de G.
Il existe deux types de graphes :
- graphe orienté : les relations sont orientées et on parle d’arc. Un arc est
représenté par un couple de sommets ordonnés.
- Graphe non orienté : les relations ne sont pas orientées et on parle alors
d’arêtes. Une arête est représentée par une paire de sommets non ordonnés.
1 2 1 2
5 5
3 4 3 4
Figure-5.1 : Exemple de graphe orienté et de graphe non orienté

Une boucle est un arc qui relie un sommet à lui-même. Dans un graphe non orienté
les boucles sont interdites et chaque arête est donc constituée de deux
sommets distincts.
Degré d’un sommet : Dans un graphe non orienté, le degré d’un sommet est le
nombre d’arêtes qui lui sont incidentes. Si un sommet est de degré 0,
comme le sommet 4 de l’exemple, il est dit isolé.
Degré sortant d’un sommet : Dans un graphe orienté, le degré sortant d’un sommet
est le nombre d’arcs qui en partent,
Degré rentrant d’un sommet : le degré entrant est le nombre d’arcs qui y arrivent et
le degré est la somme du degré entrant et du degré sortant.
Chemin : Dans un graphe orienté G = (S,A), un chemin de longueur k d’un

sommet u à un sommet v est une séquence (u0,u1,…, uk) de sommets
telle que u = u0, v = uk et (ui-1, ui) appartient à A pour tout i. Un chemin
est élémentaire si ses sommets sont tous distincts.

Un sous-chemin p0 d’un chemin p = (u0,u1, …. ,uk) est une sous-séquence contiguë
de ses sommets. Autrement dit, il existe i et j, 0<=i<= j <=k, tels que p0
= (ui,ui+1, …. ,uj).
Circuit : Dans un graphe orienté G=(S,A), un chemin (u0,u1, …. ,uk) forme un

circuit si u0 =uk et si le chemin contient au moins un arc. Ce circuit est
élémentaire si les sommets u1, ..., uk sont distincts. Une boucle est un
circuit de longueur 1.
Cycle : Dans un graphe non orienté G = (S,A), une chaîne (u0,u1,…., uk) forme
un cycle si k >= 3 et si u0 = uk. Ce cycle est élémentaire si les sommets
u1, ..., uk sont distincts. Un graphe sans cycle est dit acyclique.
Graphe connexe : Un graphe non orienté est connexe si chaque paire de sommets
est reliée par une chaîne. Les composantes connexes d’un graphe
sont les classes d’équivalence de sommets induites par la relation « est
accessible à partir de ». (figure-5.1b)
Graphe fortement connexe : Un graphe orienté est dit fortement connexe si chaque
sommet est accessible à partir de n’importe quel autre. Les composantes

fortement connexes d’un graphe sont les classes d’équivalence de
sommets induites par la relation «sont accessibles l’un à partir de l’autre
». (figure-5.1a)
Sous-graphe : On dit qu’un graphe G0 = (S0,A0) est un sous-graphe de G = (S,A) si

S0 est inclus dans S et si A0 est inclus dans A.
22- Arbres
Un graphe non orienté acyclique est une forêt et un graphe non orienté connexe
acyclique est un arbre. La figure-5.2 présente 3 graphes : un graphe qui n’est ni un
arbre ni une forêt car contenant un cycle (a), un graphe qui est une forêt mais pas un
arbre (b) et un arbre (c).
1 2 1 2
6 5 6 5
3 4 3 4
7 7
Figure-5.2 : (a) Exemple de graphe contenant un cycle. (b) Exemple d’arbre

Théorème (Propriétés des arbres) : Soit G = (S,A) un graphe non orienté. Les
affirmations suivantes sont équivalentes.
a-1. G est un arbre.
a-2. Deux sommets quelconques de G sont reliés par un unique chemin
élémentaire.
a-3. G est connexe, mais si une arête quelconque est ôtée de A, le graphe résultant
n’est plus connexe.
a-4. G est connexe et A  S 1
a-5. G est acyclique et A  S 1
a-6. G est acyclique, mais si une arête quelconque est ajoutée à A, le graphe
résultant contient un cycle.

Arbre enraciné (ou arborescence): C’est un arbre dans lequel l’un des sommets se
distingue des autres. On appelle ce sommet la racine. Ce sommet particulier impose
en réalité un sens de parcours de l’arbre et l’arbre se retrouve orienté par l’utilisation
qui en est faite.
La figure-5.3 présente deux arbres qui ne diffèrent que s’ils sont considérés comme
des arbres enracinés.
80
75
3 75 90
30 80
30
12 60 3 90
12 60
Figure-5.3 : Exemple de graphe différenciés par la racine
Ancêtre : Soit x un noeud (ou sommet) d’un arbre T de racine r. Un noeud quelconque
y sur l’unique chemin allant de r à x est appelé ancêtre de x.

Père et fils : Si (y,x) est une arc alors y est le père de x et x est le fils de y. La
racine est le seul noeud qui n’a pas de père.
Feuille ou nœud externe (ou terminal) : Un noeud sans fils est un noeud terminal ou
une feuille. Un noeud qui n’est pas une feuille est un nœud interne. Si y est un
ancêtre de x, alors x est un descendant de y.
Sous-arbre : Le sous-arbre de racine x est l’arbre composé des descendants de x,

enraciné en x.
Degré d’un nœud : Le nombre de fils du noeud x est appelé le degré de x. Donc,
suivant qu’un arbre (enraciné) est vu comme un arbre (enraciné) ou un graphe, le
degré de ses sommets n’a pas la même valeur.
Profondeur d’un nœud : La longueur du chemin entre la racine r et le noeud x est la

profondeur de x.
Profondeur de l’arbre : c’est la plus grande profondeur que peut avoir un nœud
quelconque de l’arbre. Elle est dite aussi la hauteur de l’arbre.

Arbre ordonné : c’est un arbre enraciné dans lequel les fils de chaque noeud sont
ordonnés entre eux. Les deux arbres de la figure-5.4 sont différents si on les regarde
comme des arbres ordonnés, mais ils sont identiques si on les regarde comme de
simples arbres (enracinés).
75 75
30 80 30 80
12 60 60 12 90
90
3 3
Figure-5.4 : Exemple d’arbres (enracinés) qui ne diffèrent que s’ils sont ordonnés

23- Arbre binaire :
Un arbre binaire est tel que chaque nœud a au plus deux fils.
Les arbres binaires se décrivent plus aisément de manière récursive. Un arbre binaire
T est une structure définie sur un ensemble fini de noeuds et qui :
– ne contient aucun noeud, ou
– est formé de trois ensembles disjoints de noeuds : une racine, un arbre binaire
appelé son sous-arbre gauche et un arbre binaire appelé son sous-arbre droit.
Dans un arbre binaire, si un noeud n’a qu’un seul fils, la position de ce fils—qu’il soit
fils gauche ou fils droit—est importante.
Arbre binaire complet : Dans un arbre binaire complet chaque noeud est soit une
feuille, soit de degré deux. Aucun noeud n’est donc de degré un.
Un arbre k-aire est une généralisation de la notion d’arbre binaire où chaque noeud
est de degré au plus k et non plus simplement de degré au plus 2.

24- Parcours d’un graphe
24.1 - Parcours des arbres
Nous ne considérons ici que des arbres ordonnés. Les parcours permettent
d’effectuer tout un ensemble de traitement sur les arbres.
24.1.1 Parcours en profondeur
Dans un parcours en profondeur, on descend d’abord 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. Les fils d’un noeud sont bien évidemment parcourus suivant
l’ordre sur l’arbre.
Algorithme ParPro(A)
If A n’est pas réduit à une feuille then
for tous les fils u de racine(A) do
ParPro(u)
End_PP

24.1.2 Parcours en largeur
Dans un parcours en largeur, tous les noeuds à une profondeur i doivent avoir été
visités avant que le premier noeud à la profondeur i+1 ne soit visité. Un tel parcours
nécessite l’utilisation d’une file d’attente pour se souvenir des branches qui restent à
visiter.
Algorithme Parcours_Largeur(A)
F : File d’attente
F.Put (racine(A))
While F != vide Do
u=F.Get()
Afficher (u)
For « chaque fils v de » u do
F.Put (v)
End_PL

24.2 -Parcours des graphes
Le parcours des graphes est un peu plus compliqué que celui des arbres. En effet, les
graphes peuvent contenir des cycles et il faut éviter de parcourir indéfiniment ces
cycles. Pour cela, il suffit de colorier les sommets du graphe.
- Initialement les sommets sont tous blancs,
- lorsqu’un sommet est rencontré pour la première fois il est peint en gris,
- lorsque tous ses successeurs dans l’ordre de parcours ont été visités, il est
repeint en noir.

24.2.1 Parcours en profondeur
Algorithme PP(G)
for chaque sommet u de G do
couleur[u]=Blanc
endfor
for chaque sommet u de G do
If couleur[u] = Blanc then
VisiterPP(G, u, couleur)
Endif
Endfor
End_PP
Algorithme VisiterPP(G, s, couleur)
couleur[s]=Gris
for chaque voisin v de s do
if couleur[v] = Blanc then
VisiterPP(G, v, couleur)
couleur[s]=Noir
End_VisiterPP

24.2.2 Parcours en largeur
Dans un parcours en largeur d’abord,

tous les noeuds à une Algorithme PL(G, s)
profondeur i doivent avoir été F : File d’attente visités
avant que le premier noeud à for chaque sommet u de G do la
profondeur i+1 ne soit visité. couleur[u] = Blanc Un tel
parcours nécessite l’utilisation Endfor d’une
file d’attente pour se souvenir couleur[s]=Gris des
branches qui restent à visiter. F.Put(s)
while F != Vide do
u=F.Get()
for chaque voisin v de u do
if couleur(v) = Blanc then
couleur(v)= Gris
F.Put(v)
Endfor
Couleur(u)= Noir
Endwhile
End_PL

Chap-6 : Arbres Binaires et Arbres Binaires de
Recherche
25- Définition
Un arbre ou arborescence binaire est un graphe qui admet une racine et sans cycle et
dont chaque nœud admet deux fils : fils droit et fils gauche.
On peut représenter un arbre binaire sous la forme d’une liste chaînée mais non
linéaire.
26- Implémentation d’un arbre binaire :

26.1 -Définition des structures de données :
Chaque nœud sera composé de 3 champs : un champ pour la donnée, et deux

champs pointeurs l’un pour le fils droit et l’autre pour le fils gauche. La structure de
donnée arbre contient un seul pointeur ‘racine’ qui donne le premier élément de
l’arbre.
Struct node
{ ‘type’ data ;

struct node *left ;
struct node *right; Left Data Right
};
struct arbre
{ struct node *racine ; };
26.2 -Parcours d’un arbre binaire:
Il existe 3 méthodes de parcours d’un arbre binaire :

- parcours préfixe : père, fils gauche, fils droit
- parcours infixe : fils gauche, père, fils droit
- parcours postfixe : fils gauche, fils droit, père
On ne peut réaliser ces différents parcours qu’en utilisant une pile, puisqu’on est obligé
de commencer le parcours par la racine et d’empiler les nœuds dont on n’a pas encore
rencontré le fils gauche. La pile peut être utilisée d’une manière explicite ou bien au
moyen d’une procédure récursive.

26.2.1 Parcours préfixe :
L’algorithme récursif et son implémentation en C de ce parcours sont donnés dans le

tableau suivant :
Algorithme Programme en C
Algorithme Préfixe(struct node Void PréfixeArbre (struct arbre *a)
A) { Préfixe (a -> racine) ; }
If (A != Nil) then
AfficheRacine(A) void Préfixe ( struct node *pere)
Préfixe (FilsGauche(A)) { if (pere != null)
Préfixe (FilsDroit(A)) { /* traiter la donnée pere -> data */
End_If Préfixe ( pere -> left);
End_Préfixe Préfixe (pere -> right) ;
}
}

26.2.2 Parcours infixe :

tableau suivant :
Algorithme Infixe(A) Void InfixeArbre (struct arbre *a)
If (A != Nil) then { Infixe (a -> racine) ; }
Infixe (FilsGauche(A)) void Infixe ( struct node *pere)

AfficheRacine(A) { if (pere != null)
Infixe (FilsDroit(A)) { Infixe ( pere -> left);
End_If /* traiter la donnée pere -> data */
End_Préfixe Infixe (pere -> right) ;
}
}

26.2.3 Parcours postfixe :

tableau suivant :
Algorithme Postfixe(A) Void PostfixeArbre (struct arbre *a)
If (A != Nil) then { Postfixe (a -> racine) ; }
Postfixe (FilsGauche(A))
Postfixe (FilsDroit(A)) void Postfixe ( struct node *pere)
AfficheRacine(A) { if (pere != null)
End_If { Postfixe ( pere -> left);
End_Préfixe Postfixe (pere -> right) ;
/* traiter la donnée pere -> data */
}
}

26.2.4 Parcours infixe d’un arbre en utilisant une pile :
Le programme suivant est une version dérécursivée utilisant une pile explicite et
permettant le parcours infixe d’un arbre binaire.
void parcourir_infixe ( struct arbre *a) /* en utilisant une pile */

{ struct pile pl ; /* le type des éléments de la pile est « struct node * »
struct node cur ;
init_pile ( pl) ;
cur = a-> racine ;
do
{ while ( cur != null)
{ push (pl, cur);
cur = cur -> left;
}
if (! empty_pile(pl) )
{ pop (pl, cur ) ;
/* traiter la donnée cur -> data */
cur = cur -> right ;
}

} while ( cur != null && !empty (pl));
}
26.3 -Arbre Binaire de Recherche :
Un arbre binaire de recherche est un arbre binaire dans lequel chaque nœud est
supérieur à son fils gauche et inférieur à son fils droit et il n’y a pas de nœuds égaux.
Un arbre binaire de recherche est intéressant puisqu’il est toujours possible de

connaître dans quelle branche de l’arbre se trouve un élément et de proche en proche
le localiser dans l’arbre. On peut aussi utiliser un arbre binaire de recherche pour
ordonner une liste d’éléments.
75
30 80
12 60 90

Pour utiliser un arbre binaire de recherche il va falloir résoudre trois problèmes :
 Comment permettre la multiplicité des éléments ?

Solution : Ajouter un champ dans le nœud pour indiquer la fréquence de la valeur.
 Comment construire un arbre binaire de recherche ou comment insérer un nouvel
élément dans l’arbre ?
Solution : Il faut descendre dans l’arbre jusqu’à trouver un pointeur égal à Null.
 Comment retrouver l’ordre des éléments ?
Solution : Effectuer un parcours infixe.
Exemple : Construisons un arbre binaire de 75

recherche pour la séquence de valeurs
30
suivantes : 75, 30, 60, 12, 80, 3, 90 80
Application : Lire une liste de notes dans le 12 60 90
désordre, construire un arbre binaire de
recherche et imprimer les notes dans l’ordre 3
croissant.

26.3.1 Algorithme de recherche d’un élément :
La recherche d’un élément dans un arbre binaire de recherche est très facile si on
profite du caractère récursif d’un arbre binaire.
Algorithme Chercher (Parent P , élément X)

If ( P = Null) then
Return 0
Else
If( P.data = X ) Then
Return 1
Else
If (X < P.data ) Then
Return Chercher(P.Gauche, X)
Else
Return Chercher (P.Droit, X)
Endif
Endif

Endif
End_Chercher
26.3.2 Algorithme d’insertion d’un élément :
L’élément à ajouter est inséré là où on l’aurait trouvé s’il avait été présent dans l’arbre.
L’algorithme d’insertion recherche donc l’élément dans l’arbre et, quand il aboutit à la
conclusion que l’élément n’appartient pas à l’arbre (il aboutit à la terre), il insère
l’élément comme fils du dernier noeud visité.
Algorithme Insérer (Parent P, élément X)

If (P = null)
« ajouter un nœud pour X à cet endroit»
else
If (P.data = X)
Incrémenter nombre d’exemplaires
Else
If(X> P.data)
Insérer (P.Fils droit, X)

Else
Insérer (P.Fils gauche, X)
EndInsérer
int inserer_arbre ( struct arbre *a, ‘type’ x)

{ int k;
k=inserer ( a->racine, x);
if ( k ) (a-> nb_total) ++
return k ;
}
int inserer ( struct node *parent, ‘type’ x)
{ if ( parent == null )
{ parent = new node;
parent -> gauche = parent -> droit = null;
parent -> data = x ; parent->nb_ex=1;
return 1;
} else
if ( x == parent -> data )
{ (parent -> nb_ex)++ ;

return 0 ;
} else
if ( x> parent -> data )
return ( inserer (parent -> droit, x) ) ;
else
return ( inserer (parent -> gauche, x) );
}
26.3.3 Algorithme de suppression d’un élément :
La suppression d’un élément est plus compliquée que l’insertion, car si cet élément est
un père à qui confier ses fils ?
Il existe trois cas possibles :
15
1er cas : l’élément à supprimer n’a pas de fils 15il est terminal et il suffit de le
supprimer 5 16 5 16
3 12 20 3 12 20
10 13 10
4 18 23 18 23
6 6
7 7
2ème cas : l’élément a un fils unique  on supprime le nœud et on relie son fils à son
père
15 15
5 16 5 20
3 12 3 12
20
18 23
10 13 10 13
4 18 23
6 6
7 7

3ème cas : l’élément à supprimer a deux fils  on le remplace par son successeur qui
est toujours le minimum de ses descendants droits.
15
15
5 16 6 16
3 12 20 3 12 20
10 13
18 23 10 13
4 18 23
4
6
7

26.3.4 Complexité :
Si h est la hauteur de l’arbre, on peut aisément montrer que tous les algorithmes
précédents ont une complexité en O(h). Malheureusement, un arbre binaire
quelconque à n noeuds a une hauteur comprise, en ordre de grandeur, entre log2 n et
n. Pour éviter les cas les plus pathologiques, on s’intéresse à des arbres de
recherches équilibrés.
15 6
6
25 12
3 12 17 35 15
17
25
35

7
26.4 -Arbre « Rouge et Noir » :
2 1
Un arbre rouge et noir est un type 1
d’arbres de recherche dits presque
équilibrés. 1 5 8 1
4
26.4.1 Définition Nul Nul Nul Nul Nul Nul
l l l l l l
4 1
Un arbre binaire de recherche est un 5
arbre rouge et noir s’il satisfait les Nul

l
Nul
l
Nul
l
Nul
l
propriétés suivantes :
1. Chaque noeud est soit rouge, soit noir.

2. Chaque feuille (Null) est noire.
3. Si un noeud est rouge, alors ses deux fils sont noirs.
4. Tous les chemins descendants reliant un noeud donné à une feuille (du sous-arbre
dont il est la racine) contiennent le même nombre de noeuds noirs.

Définition : On appelle hauteur noire d’un noeud x le nombre de noeuds noirs sur un
chemin descendant de x à une feuille.

Mise à jour d’un arbre « rouge et noir »
Les opérations de mise à jour d’un arbre « rouge et noir » sont un peu plus
compliquées que dans le cas d’un arbre binaire classique car il faut veiller à ne pas
violer les règles que doit vérifier un arbre « rouge et noir ».
Pour cela, on aura besoin de changer la couleur des nœuds et d’effectuer des
déplacements appelés « rotations ».
26.4.2 Rotations
Pour préserver les propriétés d’un arbre binaire de recherche « rouge et noir » lors de
la mise à jour, on aura besoin d’effectuer des rotations :
y Rotation droite (y) x
x C A y
Rotation gauche (y)
(y)
A B B C

26.4.3 Insertion
Pour insérer un nouvel élément dans un arbre « rouge et noir » :

- insérer l’élément normalement comme dans un arbre binaire de recherche
normal
- colorier le nœud en rouge car le noir provoquerait une violation de la 4 ème
propriété de l’arbre « rouge et noir »
- détecter les éventuels cas pathologiques qui violent les propriétés
- effectuer les transformations nécessaires (rotations)
26.4.4 Suppression
Pour supprimer un élément dans un arbre « rouge et noir » :

- appliquer l’algorithme de suppression dans un arbre binaire de recherche
- Si l’élément supprimé est de couleur « rouge » pas de problème : aucune
propriété n’est violée
- Par contre si le nœud supprimé est noir, la 4 ème propriété est violée. Il faudra
dans ce cas étudier les pathologies et apporter les modifications nécessaires.

26.4.5 Complexité :
Théorème : Un arbre « rouge et noir » contenant n nœuds internes a une hauteur au

plus égale à 2.log(n+1)
On peut montrer par induction que le sous-arbre (d’un arbre rouge et noir) enraciné en
un noeud x quelconque contient au moins 2 hn(x) noeuds internes, où hn(x) est la
hauteur noire de x. Sachant que la hauteur est toujours inférieure au double de la
hauteur noire on en déduit la borne donnée par le théorème.
Ce théorème montre bien que les arbres rouge et noir sont relativement équilibrés : la
hauteur d’un arbre « rouge et noir » est au pire le double de celle d’un arbre binaire
parfaitement équilibré.
Toutes les opérations sur les arbres rouge et noir sont de coût O(h), c’est-à-dire
O(logn), ce qui justifie leur utilisation par rapport aux arbres binaires de recherche
classiques.


Cours Algorithmique Et Complexite Avancee

Transféré par

Droits d'auteur :

Formats disponibles

Cours Algorithmique Et Complexite Avancee

Transféré par

Informations du document

Titre original

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

Cours Algorithmique Et Complexite Avancee

Transféré par

Droits d'auteur :

Formats disponibles

Chap-1 : Introduction & motivations

1- Qu’est-ce que l’algorithmique ?

1.1 - Définition (Algorithme).

Un algorithme est une suite finie d’opérations élémentaires constituant un schéma de

1.2 - Définition (Algorithmique)

L’algorithmique désigne le processus de recherche d’algorithme :

1.3 - Différences entre algorithmes et programmes

Un programme est la réalisation (l’implémentation) d’un algorithme au moyen d’un

Notes de cours : Algorithmique & Complexité 1/136 Hamrouni Kamel

1.4 - Qualités exigées d’un bon algorithme

Un bon algorithme doit satisfaire les qualités suivantes:

Notes de cours : Algorithmique & Complexité 2/136 Hamrouni Kamel

P(X) = anXn + an-1Xn-1 + ... + a1X + a0

Données : n et les coefficients an, ... , a0 et x

Objectif : calcul de P(X)

Notes de cours : Algorithmique & Complexité 3/136 Hamrouni Kamel

Notes de cours : Algorithmique & Complexité 4/136 Hamrouni Kamel

Notes de cours : Algorithmique & Complexité 5/136 Hamrouni Kamel

Le schéma de Horner est illustré par la figure ci-contre :

Notes de cours : Algorithmique & Complexité 6/136 Hamrouni Kamel

Étant donné un tableau A[0..n­1] de n nombres entiers positifs ou négatifs, comment

Par exemple, si le tableau contient les dix éléments:

la somme maximale est A[2..7[= A[2..6] = 187.

Notes de cours : Algorithmique & Complexité 7/136 Hamrouni Kamel

Algorithme_1 (int n , int a[ ])

Notes de cours : Algorithmique & Complexité 8/136 Hamrouni Kamel

Cette version n'effectue plus que O(n2) additions.

Notes de cours : Algorithmique & Complexité 9/136 Hamrouni Kamel

Peut-on mieux faire ?

On peut essayer une approche dichotomique en coupant le tableau en deux parties de

Notes de cours : Algorithmique & Complexité 10/136 Hamrouni Kamel

m= (g+d)/2; somme= algorithme_3 ( a, m+1 , d);

Notes de cours : Algorithmique & Complexité 11/136 Hamrouni Kamel

On invoque cette fonction par l'appel algorithme_3 (a, 0, n-1).

Notes de cours : Algorithmique & Complexité 12/136 Hamrouni Kamel

Notes de cours : Algorithmique & Complexité 13/136 Hamrouni Kamel

..\Exemples\plus_grande_somme_4.cpp int algo_4(int a[ ], int n)

Notes de cours : Algorithmique & Complexité 14/136 Hamrouni Kamel

Notes de cours : Algorithmique & Complexité 15/136 Hamrouni Kamel

But : ym = xn. Le coût de l’algorithme sera alors de m-1 = nombre de

4.1 - Algorithme trivial

yi = yi-1*y1 , i appartient à [2,n]. Résultat : yn = xn. Coût = n-1 multiplications.

Notes de cours : Algorithmique & Complexité 16/136 Hamrouni Kamel

4.2 - Méthode binaire ou méthode de « la chaîne Chinoise »

Notes de cours : Algorithmique & Complexité 17/136 Hamrouni Kamel

- Plaçons nous au cours du calcul de puissances de x. Soit j le dernier bit de la

– Deux cas sont possibles pour aj-1 :

Notes de cours : Algorithmique & Complexité 18/136 Hamrouni Kamel

Par récurrence, on peut montrer que :

 (1+log2 n)-1 élévations au carré (ne pas oublier l’étape 3) ;

Notes de cours : Algorithmique & Complexité 19/136 Hamrouni Kamel

Prenons le cas n = 15.

Nous sommes donc capables de calculer x15 en 6 multiplications.

Notes de cours : Algorithmique & Complexité 20/136 Hamrouni Kamel

Nous réappliquons l’algorithme pour calculer x3 et y5, où y = x3.

Notes de cours : Algorithmique & Complexité 21/136 Hamrouni Kamel

Peut-on faire mieux ? Oui...  L’algorithme de l’arbre (à découvrir)

Notes de cours : Algorithmique & Complexité 22/136 Hamrouni Kamel

La TF discrète est donnée par :

Étant donné un tableau A[0..n1] de n nombres entiers positifs ou négatifs, comment