Algo Avancée (Notes de Hamrouni)

Notes de cours : Algorithmique & Complexit 1/140 Hamrouni Kamel
Chap-1 : Introduction & motivations

1- Quest-ce que lalgorithmique ?

1.1 - Dfinition (Algorithme).
Un algorithme est une suite finie doprations lmentaires constituant un schma de
calcul ou de rsolution dun problme.
1.2 - Dfinition (Algorithmique)
Lalgorithmique dsigne le processus de recherche dalgorithme :
1.3 - Diffrences entre algorithmes et programmes
Un programme est la ralisation (limplmentation) dun algorithme au moyen dun
langage donn (sur une architecture donne). Il sagit de la mise en oeuvre du
principe. Par exemple, lors de la programmation on soccupera parfois, explicitement

de la gestion de la mmoire (allocation dynamique en C) qui est un problme
dimplmentation ignor au niveau algorithmique.
1.4 - Qualits exiges dun bon algorithme
Un bon algorithme doit satisfaire les qualits suivantes:

Correct: Il faut que le programme excute correctement les tches pour lesquelles il a
t conu

Complet: Il faut que le programme considre tous les cas possibles et donne un
rsultat dans chaque cas.

Efficace: Il faut que le programme excute sa tche avec efficacit cest dire avec
un cot minimal. Le cot pour un ordinateur se mesure en termes de
temps de calcul et despace mmoire ncessaire.


2- Problme_1 : Valeur dun polynme
On voudrait laborer un algorithme permettant de calculer pour une valeur X donne
de type REAL la valeur numrique d'un polynme de degr n:

P(X) = a
n
X
n
+ a
n-1
X
n-1
+ ... + a
1
X + a
0

Donnes : n et les coefficients a
n
, ... , a
0
et x

Objectif : calcul de P(X)


2.1 - Algorithme_1 ( trivial) :
begin
P=0
for k=0 to n do
P = P+ a
k
*X
K

endfor
end

Cot de lalgorithme:
- (n+1) additions
- (n+1) multiplications
- (n+1) puissances


2.2 - Algorithme_2 (sans puissance) :
begin
XP=1 ; P =0
for K=0 to N do
P = P+ XP*a
k

XP = XP * X
endfor
end

Cot de lalgorithme:
- (n+1) additions
- 2(n+1) multiplications

2.3 - Algorithme_3 (Schma de Horner):

Le schma de Horner est illustr par la figure ci-contre :

P(x) = (.(((a
n
x+a
n-1)
x+a
n-2
)x+a
n-3
)..)x+a
0

lalgorithme

begin
P = a
n

for k = n-1 to 0 step 1 do
P = P*X + a
k

endfor
end

. Peut-on faire mieux ?
Cot de lalgorithme:
- (n) additions
- (n) multiplications



3- Problme-2: La plus grande somme contigu
Le but est dlaborer un algorithme permettant de calculer la plus grande somme
contigu d'une squence d'entiers placs dans un tableau.

tant donn un tableau A[0..n-1] de n nombres entiers positifs ou ngatifs, comment
dterminer 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 lments:

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 (naf) :
L'ide la plus simple est de calculer toutes les sommes et de rechercher la plus
grande, par un algorithme du style:

Il est facile de voir que la
comparaison entre
Maximum et Somme est effectue
O(n
3
) fois.

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]
Endfor
If (Somme > Maximum) then
Maximum = Somme
Endfor
Endfor
Return Maximum
End_algorithme

..\Exemples\plus_grande_somme_1.cpp
Peut-on mieux faire ?
3.2 - Algorithme_2 :
Une meilleure ide consiste ne pas recalculer systmatiquement les sommes mais
utiliser la relation:
1
1
+
=
+
=
+ =
j
j
i k
k
j
i k
k
a a a

D'o le nouveau programme:

Algorithme_2 (int n , int a[ ])
Maximum=0;
For i=0 to n-1 do
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(n
2
) additions.


On peut essayer une approche dichotomique en coupant le tableau en deux parties de
tailles quivalentes et en disant que la somme maximale est ralise soit totalement
dans la partie droite, soit totalement dans la partie gauche, soit cheval. La valeur
recherche est ncessairement la plus grande des trois sommes. Cette ide nous
conduit lalgorithme rcursif suivant :


Algorithme_3(int a[ ], int g, int d)
{ int m, max1, max2, maximum ;
int somme, i;

if (g > d ) then
return 0;
endif
if (g ==d ) then
if (a[g] > 0 )
return a[g];
else
return 0;
endif
m= (g+d)/2;
max1=0; somme = 0;
for i=m to g step -1 do
somme = somme +a[i];
if (somme > max1)
max1= somme;
endfor
max2= 0 ; somme =0;
for i=m+1 to d do
somme= somme+ a[i];
if (somme > max2) then
max2= somme;
endfor

maximum = max1 + max2;
somme= algorithme_3 (a, g, m);
if ( somme > maximum ) then
maximum =somme;
endif

somme= algorithme_3 ( a, m+1 , d);
if ( somme > maximum ) then
maximum =somme;
endif
return maximum;

End_algorithme


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

Complexit de lalgorithme :
Cet algorithme est de type diviser pour rgner . Le nombre de comparaisons
effectues lintrieur de la fonction rcursive est gal (d-g) fois. Il est donc O(n).
Lquation rcurrente de sa complexit est donc:

On dmontrera plus loin en utilisant le thorme qui sera prsent 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'ide cette fois est de parcourir une seule fois le
tableau et de maintenir simultanment deux maximums : la plus grande somme
max1 et un max2 qui est remis zro chaque fois quil devient ngatif. La plus
grande somme recherche est gale soit max1 soit max2 d'o l'algorithme:


Il est clair que cet algorithme est en O(n).


La rponse est non car tout algorithme
rsolvant ce problme est oblig de
parcourir l'intgralit des donnes, donc a une
complexit au moins linaire.

int algo_4(int a[ ], int n)
int max1 = 0, max2 = 0, i ;
for i = 0 to n-1 do
max2 = max2 + a[i] ;
if (max2 < 0) then
max2 = 0 ;
endif
if (max2 > max1) then
max1 = max2 ;
endif
endfor
return max1 ;
End_algorithme


Sur un PC 400MHz, pour un tableau de taille 10
7
Jon Bentley, (Programming Pearls,
Addison-Wesley, 2000) ) donne l'estimation suivante des temps d'excution:

Algorithme 1 2 3 4
Temps 41000 ans 1,7 semaines 11 secondes 0,48 seconde

4- Problme_3 : calcul de x
n

Donnes : Un entier naturel n et un rel x.
Objectif : Calculer x
n
.
Ide : 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 prcdemment calcules : yk = yu *yv, avec 1<=u , v < k, k appartient
[2,m].

But : ym = x
n
. Le cot de lalgorithme sera alors de m-1 = nombre de
multiplications faites pour obtenir le rsultat recherch.
4.1 - Algorithme trivial
y
i
= y
i-1
*y
1
, i appartient [2,n]. Rsultat : y
n
= x
n
. Cot = n-1 multiplications.

Algorithme
y = x
For i =2 to n do
y = y * x
End_for

Return y
End_Algorithme
4.2 - Mthode binaire ou mthode de la chane Chinoise
Historique :
Cette mthode a t prsente 200 avant J.C. en Inde (ou en Chine), mais il
semblerait quil ait fallu attendre un millnaire avant que cette mthode ne soit connue
en dehors de lInde [Knuth].
Algorithme
1. crire n sous forme binaire
2. Remplacer chaque :
1 par la paire de lettres
SX ;
0 par la lettre S .
3. liminer la paire SX
la plus gauche.
4. Rsultat : Une chane de caractres
contenant les lettres S et X.
5. Calcul de x
n
:
- partir de x et parcourir la chane
Illustration avec x
23

1. n = 23 = 10111
1 0 1 1 1
2. SX S SX SX SX

3. S SX SX SX

4. Rsultat : SSXSXSX

5. Nous partons de x et nous obtenons
successivement :

de caractres
- chaque S
lever au carr ;
- chaque X
multiplier par x .
x,x
2
, x
4
, x
5
, x
10
, x
11
, x
22
, x
23
.

Nous sommes donc capables de
calculer x
23
en 7 multiplications au lieu
de 22

Explication de la mthode
criture binaire de n :
=
=
p
i
i
i
a n
0
2

- Plaons nous au cours du calcul de puissances de x. Soit j le dernier bit de la
reprsentation binaire de n qui a t dcod et soit yj le dernier rsultat obtenu.
(Initialement, j = p et yp = x = x
ap
). j varie de p 0.

Deux cas sont possibles pour aj-1 :
1
er
cas : aj-1 = 1 alors aj-1 est remplac par SX, nous levons yj au carr
puis multiplions le rsultat par x. Le nouveau rsultat est :
x y y
j j
2
1
=

2
me
cas : aj-1 =0 alors aj-1 est remplac par S et nous levons simplement yj
au carr. Le nouveau rsultat est
2
1 j j
y y =

Dans tous les cas nous avons :
1 2
1

=
j
a
j j
x y y

Do :

) ( ) )( ( ) ( ) (
1 1 1 1
2 2
2 2
1

+
= = = =
p p p p p p p
a a a a a a a
p p
x x x x x x y y

Par rcurrence, on peut montrer que :
n
a
x x y
i
p
i
i
=
=
=
2
0
0

Complexit (cot)

Notes :
- les nombres dont la reprsentation binaire ont exactement p chiffres forment
exactement lintervalle :
] 1 2 , 2 [
1
p p

- Nombres de chiffres dans lcriture binaire de n = 1+[log2 n]. Notons v(n) le
nombre de 1 dans lcriture binaire de n.
Nombre doprations effectues =

- (1+log2 n)-1 lvations au carr (ne pas oublier ltape 3) ;
- v(n)-1 multiplications par x (ne pas oublier ltape 3).

Soit en tout : T(n) = log2 n+v(n)-1 multiplications.
Sachant que : 1 <= v(n) <= log2 n log2 n <=T(n) <= 2log2 n
Pour n = 1000, lalgorithme trivial effectue 999 multiplications, et la mthode 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 : x
2
, x
3
, x
6
, x
7
, x
14
, x
15
.

Nous sommes donc capables de calculer x
15
en 6 multiplications.

Autre schma de calcul : x
2
, x
3
, x
6
, x
12
et faisons x
15
= x
12
x x
3

Nous obtenons ainsi x
15
en 5 multiplications

la mthode binaire nest donc pas optimale (cest--dire que lon peut faire mieux).

4.3 - Algorithme des facteurs
Algorithme
n de ppdp le p avec n p n si
premier n si
n si
x
x x
x
x
n p
n n
' .
1
) (
.
'
1
=
=
=

ppdp : le plus petit diviseur premier

Illustration avec n = 15
1. 15 = 3x5, 3 tant le plus petit diviseur (facteur) premier de 15. Donc x
15
= (x
3
)
5
.

Nous rappliquons lalgorithme pour calculer x
3
et y
5
, o y = x
3
.
2. Calcul de x
3
:
(a) 3 est premier. Donc x
3
= x
2
.x
Nous rappliquons lalgorithme pour calculer x
2
.
(b) 2 est premier. Donc x
2
= x.x
(c) Finalement, x
3
est calcul comme suit : x
3
= x.x.x, soit en deux multiplications.
3. Calcul de y
5
:

(a) 5 est premier. Donc y
5
= y
4
.y Nous rappliquons lalgorithme pour calculer
y
4
.
(b) 4 = 2x2, o 2 est le plus petit facteur premier de 4. Donc y
4
= (y
2
)
2
.
(c) Finalement y
5
est calcul comme suit : t = y.y, u = t.t, y
5
= u.y, soit en 3
multiplications.
4. Finalement, x
15
est calcul en 5 multiplications.

Peut-on faire mieux ? Oui... Lalgorithme de larbre ( dcouvrir)

Nous avons affaire un problme simple, que tout le monde sait rsoudre, mais
quil est trs difficile de rsoudre efficacement...

5- Problme_4 : Calcul de la Trans. de Fourier
Transforme de Fourier 1-D continue (rappel) :
Si f(x) est continue et intgrable, alors la transforme de Fourier continue est dfinie
par :
}
+

= dx
e
x f u F
ux jt 2
) ( ) (
et linverse
}
+

= du
e
u F x f
ux jt 2
) ( ) (

La TF discrte est donne par :

=
1
0
/ 2
) (
/ 1 ) (
N
x
N ux j
e x f
N u F
t
et
=
=
1
0
/ 2
) (
) (
N
u
N ux j
e u F
x f
t

Donnes : N chantillons de la fonction f(i), pour i=0,1,, n

Objectifs : Calculer F(u) pour une valeur de u donne


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) // oprations complexes
Endfor

Cot de lalgorithme:
- (n+1) additions complexes
- (n+1) multiplications complexes
- (n+1) multiplications relle
- (n+1) calcul dune exponentielle

5.2 - Algorithme de Tookey Kooley
On pose :
) / 2 exp( N ux i W
ux
N
t =
et
) / 2 exp( N i W
N
t =

)
`
+
+ =

=
+
1
0
1
0
) 1 2 (
2
) 2 (
2 ) 1 2 (
/ 1
) 2 (
/ 1 2 / 1 ) (
M
x
M
x
x u
M
x u
M W x f
M
W x f
M u F

{ }
u
M
impaire paire W u F u F u F
2
) ( ) ( 2 / 1 ) ( + =

Par rcursivit, le calcul de la TF se ramne au calcul de la TF de 2 chantillons

Exemple : Fonction 8 chantillons


il suffit davoir une fonction rcursive qui calcule la TF de deux points

Cot de lalgorithme:
On dmontre que pour calculer la TF dune fonction n chantillons :
T(n) est fonction de nlog
2
(n) (voir thorme plus loin)
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


6- Conclusion
- Existence de plusieurs solutions pour un problme donn
- Ces solutions peuvent tre correctes mais nont pas la mme efficacit (cot)
- Avant de proposer un algorithme, il faut estimer son cot
- Et se poser la question de lexistence dune autre solution moins coteuse

Chap-2 : Complexit et optimalit

7- Dfinition de la complexit
7.1 - Dfinition (Complexit):
La complexit dun algorithme est la mesure du nombre doprations fondamentales
quil effectue sur un jeu de donnes. La complexit est fonction de la taille du jeu de
donnes.
Nous notons Dn lensemble des donnes de taille n et T(d) le cot de lalgorithme sur la
donne d.
On dfinit 3 types de complexit :
- Complexit au meilleur
- Complexit au pire
- Complexit moyenne

7.2 - Complexit au meilleur :
) ( min ) (
min
d C n T
n
D de
=
Cest le plus petit nombre doprations quaura excuter lalgorithme sur un jeu de
donnes de taille fixe, ici n. Cest une borne infrieure de la complexit de
lalgorithme sur un jeu de donnes de taille n.

7.3 - Complexit au pire :
) ( max ) (
max
d C n T
n
D de
=

Cest le plus grand nombre doprations quaura excuter lalgorithme sur un jeu de
donnes de taille fixe, ici n.
Avantage : il sagit dun maximum, et lalgorithme finira donc toujours avant davoir
effectu Tmax(n) oprations.
Inconvnient : cette complexit peut ne pas reflter le comportement usuel de
lalgorithme. Le pire cas ne peut se produire que trs rarement, mais il nest pas rare
que le cas moyen soit aussi mauvais que le cas pire.

7.4 - Complexit en moyenne :
n
D d
moy
D
d C
n T
n
e
=
) (
) (

Cest la moyenne des complexits de lalgorithme sur des jeux de donnes de taille n
(en toute rigueur, il faut bien videmment tenir compte de la probabilit dapparition de
chacun des jeux de donnes).
Avantage : reflte le comportement gnral de lalgorithme si les cas extrmes
sont rares ou si la complexit varie peu en fonction des donnes.
Inconvnient : en pratique, la complexit sur un jeu de donnes 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 lalgorithme.
En pratique, nous ne nous intresserons qu la complexit au pire et la complexit
en moyenne.

8- Dfinition de loptimalit :

Un algorithme est dit optimal si sa complexit est la complexit minimale parmi les
algorithmes de sa classe.
Nous nous intresserons quasi exclusivement la complexit en temps des
algorithmes. Il est parfois intressant de sintresser dautres ressources, comme la
complexit en espace (taille de lespace mmoire utilis), la largeur de bande
passante requise, etc.
9- Illustration : cas du tri par insertion
9.1 - Problmatique du tri
Donnes : une squence de n nombres, a1, ..., an.
Rsultats : une permutation a
i
de la squence dentre, telle que i a a
i i
s
+1
' '
9.2 - Principe du tri par insertion
De manire rpte, on retire un nombre de la squence dentre et on linsre la
bonne place dans la squence des nombres dj tris (ce principe est le mme que
celui utilis pour trier une poigne de cartes).
9.3 - Algorithme

For j=2 to n do
cl = A[ j]
i= j-1
while (i > 0 and A[i] > cl) do
A[i+1]=A[i]
i=i-1
End_while
A[i+1]=cl
Endfor
On retire un nombre de la squence
dentre.
Les j-1 premiers lments de A sont
dj tris.
Tant que lon nest pas arriv au dbut
du tableau, et que llment courant
est plus grand que celui insrer.
On dcale llment courant (on le met
dans la place vide).
Finalement, on a trouv o insrer
notre nombre.

9.4 - Complexit
Attribuons un cot en temps chaque instruction, et comptons le nombre dexcutions de
chacune des instructions. Pour chaque valeur de ] , 2 [ n j e , nous notons t
j
le nombre
dexcutions de la boucle while pour cette valeur de j. Il est noter que la valeur de t
j

dpend des donnes...

Instruction Cot unitaire Cot total
For j=2 to n do
cl = A[ j ]
i= j-1
while (i > 0 and A[i] > cl) do

A[i+1]=A[i]

i=i-1
End_while
A[i+1]=cl
Endfor
c1
c2
c3
c4

c5

c6

c7

n
n-1
n-1
=
n
j
j
t
2

) 1 (
2

=
n
j
j
t
) 1 (
2

=
n
j
j
t

n-1

Le temps dexcution total de lalgorithme est alors la somme des cots lmentaires:

) 1 ( ) 1 ( ) 1 ( ) 1 ( ) 1 ( ) (
7
2
6
2
5
2
4 3 2 1
+ + + + + + =

= = =
n c t c t c t c n c n c n c n T
n
j
j
n
j
j
n
j
j
Complexit au meilleur :

le cas le plus favorable pour lalgorithme TRI-INSERTION est quand le tableau est dj
tri. Dans ce cas t
j
= 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 indpendantes des
entres, et
T(n) est donc une fonction linaire de n.
Le plus souvent, comme cest le cas ici, le temps dexcution dun algorithme est fix pour une
entre donne; mais il existe des algorithmes alatoires intressants dont le comportement
peut varier mme pour une entre fixe.
Complexit au pire :
Le cas le plus dfavorable pour lalgorithme TRI-INSERTION est quand le tableau est dj tri
dans lordre inverse. Dans ce cas t
j
= j pour tout j.
Rappel :
2
) 1 (
) 1 ( 1
2
) 1 (
2
) 1 (
2 2 1
=
+
=
+
=

= = =
n n
j et
n n
j donc
n n
j
n
j
n
j
n
j

) 1 ( )
2
) 1 (
( )
2
) 1 (
( ) 1
2
) 1 (
( ) 1 ( ) 1 ( ) (
7 6 5 4 3 2 1
+
+
+
+ + + = n c
n n
c
n n
c
n n
c n c n c n c n T

) ( ) 2 2 2 (
2
1
) (
2
1
) (
7 4 3 2 7 6 5 4 3 2 1
2
6 5 4
c c c c n c c c c c c c n c c c n T + + + + + + + + + + =
T(n) est donc de la forme c bn an n T + + =
2
) (
T(n) est donc une fonction quadratique de n.

Complexit en moyenne :
Supposons que lon applique lalgorithme de tri par insertion n nombres choisis au
hasard. Quelle sera la valeur de tj ? Cest--dire, o devra-t-on insrer A[ j] dans le
sous-tableau A[1.. j-1] ?
En moyenne, la moiti des lments de A[1.. j-1] sont infrieurs A[ j], et lautre moiti
sont suprieurs. Donc t j = j/2. Si lon reporte cette valeur dans lquation dfinissant
T(n), on obtient, comme dans le cas pire, une fonction quadratique en n.
Ordre de grandeur :
Ce qui nous intresse vraiment, cest lordre de grandeur du temps dexcution. Seul le
terme dominant de la formule exprimant la complexit nous importe, les termes
dordres infrieurs ntant 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 = O(n).
Complexit au pire = O(n
2
).
Complexit en moyenne = O(n
2
).

En gnral, on considre quun algorithme est plus efficace quun autre si sa
complexit dans le cas pire a un ordre de grandeur infrieur.
Classes de complexit
Les algorithmes usuels peuvent tre classs en un certain nombre de grandes classes
de complexit :
1. O(logn) : Les algorithmes sub-linaires dont la complexit est en gnral en
O(logn).
2. O(n) : Les algorithmes linaires en complexit O(n)
3. O(nlogn) : et ceux en complexit en O(nlogn)
4. O(n
k
) : Les algorithmes polynomiaux en O(n
k
) pour k > 3
5. Exp(n) : Les algorithmes exponentiels
Les trois premires classes sont considres rapides alors que la quatrime est
considre lente et la cinquime classe est considre impraticable.


log
2
(n) n nlog
2
(n) n
2
n
3
n
4
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

n
T(n)
Log(n)
n.Log(n)
n
n
2

n
3

a
n

Quadratique
Exponentielle

Chap-3 : La Rcursivit, Souplesse et Complexit

10- Rcursivit
De lart et la manire dlaborer des algorithmes pour rsoudre des problmes quon
ne sait pas rsoudre soi-mme !
10.1 - Dfinition
Une dfinition rcursive est une dfinition dans laquelle intervient ce que lon veut
dfinir.

Un algorithme est dit rcursif lorsquil est dfini en fonction de lui-mme.

10.2 - Rcursivit simple
Revenons la fonction puissance x x
n
. Cette fonction peut tre dfinie
rcursivement :

1
0
.
1
1
>
=
=

n si
n si
x x
x
n
n

Lalgorithme correspondant scrit :

Puissance (x, n)
Begin
If (n = 0) then
return 1
Else
return (x*Puissance (x, n-1))
End

10.3 - Rcursivit multiple
Une dfinition rcursive peut contenir plus dun appel rcursif.
Exemple_1 : Nombre de Combinaisons
On se propose de calculer le nombre de combinaisons
p
n
C
en se servant de la
relation de Pascal :
on
n p ou p si
C C
C
p
n
p
n
p
n
sin
0 1
1
1 1
= =
+
=

Lalgorithme correspondant scrit :
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 - Rcursivit mutuelle
Des dfinitions sont dites mutuellement rcursives si elles dpendent les unes des
autres. a peut tre le cas pour la dfinition de la parit :
on
n si
n impair
vrai
n pair
sin
0
) 1 (
) (
=
=
et
on
n si
n pair
faux
n impair
sin
0
) 1 (
) (
=
=

Les algorithmes correspondants scrivent :

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

10.5 - Rcursivit imbrique
La fonction dAckermann est dfinie comme suit :
on
n et m si
m si
n m A m A
m A
n
n m A
sin
0 0
0
)) 1 , ( , 1 (
) 1 , 1 (
1
) , ( = >
=

+
=

do lalgorithme :
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 rcursivit
Principe et intrt :
Ce sont les mmes que ceux de la dmonstration par rcurrence en mathmatiques.
On doit avoir :
- un certain nombre de cas dont la rsolution est connue, ces cas simples
formeront les cas darrt de la rcursivit
- un moyen de se ramener dun cas compliqu un cas plus simple.
La rcursivit permet dcrire des algorithmes concis et lgants.
Difficults :
la dfinition peut tre dnue de sens :
Algorithme A(n)
renvoyer A(n)
il faut tre sr quon retombera toujours sur un cas connu, cest--dire sur un cas
darrt ; il nous faut nous assurer que la fonction est compltement dfinie, cest--
dire, quelle est dfinie sur tout son domaine dapplications.

Moyen : existence dun ordre strict tel que la suite des valeurs successives des
arguments invoqus par la dfinition soit strictement monotone et finit toujours par
atteindre une valeur pour laquelle la solution est explicitement dfinie.

Exemple : Lalgorithme 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 dcroissante, car a est
strictement positif, et on finit toujours par aboutir un couple darguments (a,b) tel que
b-a est ngatif, cas dfini explicitement.

10.7 - Importance de lordre des appels rcursifs
Fonction qui affiche les entiers par ordre dcroissant, de n jusqu 1 :

Dcroissant (n)
If (n = 0 )Then ne rien faire
Else
afficher n
Dcroissant (n-1)
End_if
End_Dcroissant

Croissant (n)
If ( n = 0) Then ne rien faire
Else
Croissant (n-1)
afficher n
Endif
End_Croissant

Dcroissant(2) affiche :2 suivi de 1

Croissant(2) affiche : 1 suivi de 2

10.8 - Exemple dalgorithme rcursif : les tours de Hano
Le problme
Le jeu est constitu dune plaquette de bois o sont plantes trois tiges numrotes 1,
2 et 3. Sur ces tiges sont empils des disques de diamtres tous diffrents. Les seules
rgles du jeu sont que lon ne peut dplacer quun seul disque la fois, et quil est
interdit de poser un disque sur un disque plus petit.
Au dbut, tous les disques sont sur la tige 1 (celle de gauche), et la fin ils doivent
tre sur celle de droite.
Rsolution :
Principe : On suppose que lon sait rsoudre le
problme pour (n-1) disques. Pour dplacer n disques de la
tige 1 vers la tige 3, on dplace les (n-1) plus petits disques
de la tige 1 vers la tige 2, puis on dplace le plus gros disque
de la tige 1 vers la tige 3, puis on dplace les (n-1) plus petits
disques de la tige 2 vers la tige 3.


Validit : il ny a pas de viol des rgles possible puisque le plus gros disque est
toujours en bas dune tige et que lhypothse (de rcurrence) nous assure que
nous savons dplacer le bloc de (n-1) disques en respectant les rgles.
Algorithme
Hanoi (n, dpart, intermdiaire, destination)
If n > 0 Then
Hanoi (n-1, dpart, destination, intermdiaire)
dplacer un disque de dpart vers destination
Hanoi (n-1, intermdiaire, dpart, destination)
Endif
End_Hanoi

Lappel Hanoi(3,1,2,3) entrane laffichage de :
1. Dplace un disque de la tige 1 vers la tige 3

7. Dplace un disque de la tige 1 vers la tige 3 ..\Exemples\Hanoi.cpp

Complexit
On compte le nombre de dplacements de disques effectus par lalgorithme Hanoi
invoqu sur n disques.
on
n si
n C on
n si
n C n C
n C
sin
1
) 1 ( 2 1
1
sin
1
) 1 ( 1 ) 1 (
1
) (
=
+
=
=
+ +
=
Et on en dduit facilement (dmonstration par rcurrence) que :
1 2 ) ( =
n
n C

On a donc ici un algorithme de complexit exponentielle.
En supposant que le dplacement dun disque ncessite 1minute (il faut rflchir et
dplacer un disque qui peut tre lourd puisquil est en or), et si on dispose de 64
disques, il faudrait :
1 2 ) (
64
= n C
minutes = 3,50965 10
13
= 35096,5 milliards d'annes

11- Drcursivation
Drcursiver, cest transformer un algorithme rcursif en un algorithme quivalent ne
contenant pas dappels rcursifs.
11.1 - Rcursivit terminale
Dfinition (Rcursivit terminale) :
Un algorithme est dit rcursif terminal sil ne contient aucun traitement aprs un appel
rcursif.
Exemple :
Algorithme P(U)
If ( Condition(U) ) Then
Traitement_base (U);
P(o(U)) ;
Else
Traitement_terminaison(U)
;
Endif
End_Algorithme
U est la liste des paramtres ;
C est une condition portant sur U ;
o(U) reprsente la transformation
des paramtres ;


Algorithme drcursive :

Algorithme P(U)
While ( Condition(U) ) do
Traitement_base(U);
U o(U)
End_while
Traitement_terminaison;
End_Algorithme

Lalgorithme P non rcursif quivaut lalgorithme P.
Remarquer la prsence dune boucle.

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

Version rcursive Version drcursive
Diviseur (a,b)
Else
Else
End_Diviseur

?

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

Diviseur (a,b)
Else
Else
End_Diviseur

Diviseur(a,b)
If (a <= 0 )then Erreur
While ( b > a )
b=b-a

return (a=b)
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)
If ( N = 0)
Return 1 ;
Else
Return N*Factoriel (N-1) ;
End_Factoriel
Factoriel (N)
F=1;
For i=N step -1 to 1 do
F=F*i

End_Factoriel

Rcursivit non terminale
Dans lalgorithme suivant la rcursivit nest pas terminale puisque lappel rcursif est
suivi dun traitement. Cela implique quil reste un traitement reprendre
ultrieurement. Il va falloir donc sauvegarder, sur une pile, le contexte de lappel
rcursif, typiquement les paramtres de lappel engendrant lappel rcursif.
Algorithme rcursif :
Algorithme Q(U)
If ( Condition(U) ) Then
Traitement_A(U);
Q(o(U));
Traitement_B(U)
Else
Traitement_terminaison(U)
Endif
End_Algorithme

Algorithme drcursiv :
Algorithme Q(U)
Pile.init() ;

While (Condition (U)) do
Traitement_A(U) ;
Pile.push(U) ;
U= o(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)
{ if ( n> 0)
{ cout<<"\nIN : N = "<<n<< endl ;
recursif(n-1);
cout << "\nOUT : N = "<<n<<endl;
}else
cout << "\nTerminaison"<<endl;
}
void non_recursif(int &n)
{ pile P;int k;
P.init();
k=n;
while (k>0)
{ cout<<"\nIN : N = "<<k<< endl ;
P.push(k);
k--;
}
cout << "\nTerminaison"<<endl;
while (!P.empty())
{ P.pop(n) ;
cout << "\nOUT : N = "<<n<<endl;
}
}

..\Exemples\Derecursive.cpp


11.2 - Remarques
Les programmes itratifs sont souvent plus efficaces, mais les programmes rcursifs
sont plus faciles crire.
Il est toujours possible de drcursiver un algorithme rcursif.

12- Diviser pour rgner
12.1 - Principe
De nombreux algorithmes ont une structure rcursive: pour rsoudre un problme
donn, ils sappellent eux-mmes rcursivement une ou plusieurs fois sur des
problmes trs similaires, mais de tailles moindres, rsolvent les sous problmes de
manire rcursive puis combinent les rsultats pour trouver une solution au problme
initial.
Le paradigme diviser pour rgner donne lieu trois tapes chaque niveau de
rcursivit :
Diviser le problme en un certain nombre de sous-problmes ;
Rgner sur les sous-problmes en les rsolvant rcursivement ou, si la taille dun
sous-problme est assez rduite, le rsoudre directement ;
Combiner les solutions des sous-problmes en une solution complte du problme
initial.

12.2 - Exemple_1 : Recherche du maximum dun tableau

maximum ( x , left, right)
if ( left = right)
return left;
else
m=(left+right)/2 // division
du problme en 2 sous-
problmes
k1 = maximum (x, left, m ) // rgner sur le 1er sous-problme
k2 = maximum (x, m+1, right)// rgner sur le 2
me
sous-problme
if(x(k1) > x(k2)) // combiner les solutions
return k1
else
return k2
End_maximum
problme
Sous-problme1 Sous-problme2

12.3 - Eexemple_2 : multiplication nave de matrices
Nous nous intressons ici la multiplication de matrices carres de taille n.
Algorithme naf
Lalgorithme classique est le suivant :
Soit n la taille des matrices carrs A et B
Soit C une matrice carre 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 O(n
3
) multiplications et autant dadditions.

Algorithme diviser pour rgner naf
Dans la suite nous supposerons que n est une puissance de 2. Dcomposons les
matrices A, B et C en sous-matrices de taille n/2 x n/2. Lquation C = AB peut alors se
rcrire :
|
|
.
|
\
|
|
|
.
|
\
|
=
|
|
.
|
\
|
h f
g e
d c
b a
u t
s r
*

En dveloppant cette quation, nous obtenons :
r = ae+bf ; s = ag+bh; t = ce+df et u = cg+dh:

Chacune de ces quatre oprations correspond :
- deux multiplications de matrices carres de taille n/2 2T(n/2)
- et une addition de telles matrices O(n
2
)

A partir de ces quations on peut aisment driver un algorithme diviser pour rgner
dont la complexit est donne par la rcurrence :
T(n) = 8T(n/2)+O(n
2
)

12.4 - Analyse des algorithmes diviser pour rgner
Lorsquun algorithme contient un appel rcursif lui-mme, son temps dexcution
peut souvent tre dcrit par une quation de rcurrence qui dcrit le temps dexcution
global pour un problme de taille n en fonction du temps dexcution pour des entres
de taille moindre.
La rcurrence dfinissant le temps dexcution dun algorithme diviser pour rgner
se dcompose suivant les trois tapes du paradigme de base :
1. Si la taille du problme est suffisamment rduite, n <= c pour une certaine constante
c, la rsolution est directe et consomme un temps constant O(1).
2. Sinon, on divise le problme en a sous-problmes chacun de taille 1/b de la taille du
problme initial. Le temps dexcution total se dcompose alors en trois parties :
- D(n) : le temps ncessaire la division du problme en sous-problmes.
- aT(n/b) : le temps de rsolution des a sous-problmes.
- C(n) : le temps ncessaire pour construire la solution finale partir des solutions
aux sous-problmes.

La relation de rcurrence prend alors la forme :

on
c n si
n C n D b n aT
n T
sin ) ( ) ( ) / (
) 1 (
) (
s
+ +
O
=

Notations de Landau
Quand nous calculerons la complexit dun algorithme, nous ne calculerons
gnralement 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 (Mathmaticien Allemand ) :

) ( . ) ( , 0 / , 0 , 0 ) ( : n g c n f n n c n g f s > > - - O = O

On dit aussi que f est domine 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(n
2
).

) ( ) ( : f g g f O = O = O

Cela signifie que g est majore par f

) ( . ) ( , 0 / 0 , 0 ) ( : n g c n f n n n c g o f o s > - > =

Ceci signifie que : f est ngligeable devant g

Exemples : sqrt(n) = o(n), log(n) = o(n), n = o(n
2
), log(n) = o(sqrt(n)).
) ( ) ( ) ( : f g et g f g f O = O = O = O

Ceci signifie que :
) ( . ) ( ) ( . 0 / 0 , , ) ( n g c n f n g d n n n R d c g f s s > - e - O =
+

Ce qui veut dire que chaque fonction est un majorant de lautre ou encore que les
deux fonctions sont de mme ordre de grandeur asymptotique
Exemples : n+log(n) = O(n+sqrt(n)).

Remarques :
On peut considrer que :
) (g O est une borne suprieure
) (g O est une borne infrieure
) (g O est une borne exacte. Celle-ci est donc plus prcise que les prcdentes

Rsolution des rcurrences
12.5 - quations de rcurrence linaires
Exemple : La suite de Fibonacci est dfinie par :
on
n si
u u
u
n n
n
sin
2 1
2 1
<
+
=

Un algorithme rcursif 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 dadditions effectues par cet algorithme. T(n) vrifie les quations
suivantes :

2
1
0
) 2 ( ) 1 ( 1
0
0
) (
>
=
=
+ +
=
n si
n si
n si
n T n T
n T
Cette quation est linaire et dordre 2 car chaque terme de rang >1 dpend
uniquement des deux termes qui le prcdent.
Dfinition : Une quation rcurrente est dite linaire dordre k si chaque terme
sexprime comme combinaison linaire des k termes qui le prcdent plus une
certaine fonction de n.
) ( . ... . .
2 2 1 1
n f u u u u
k n k n n n
+ + + + =

o o o

Il faut bien sr connatre les k premiers termes.
A lordre 1, lquation devient :
) ( .
1
n f u a u
n n
+ =

Par itration et sommation on trouve :
)
) (
(
1
0
=
+ =
n
i
i
n
n
a
i f
u a u

Exemple : Problme des tours de Hanoi
Le cot de lalgorithme rcursif est :
1
0
1 ) 1 ( 2
0
) (
>
=
+
=
n
n
si
si
n T
n T T(n) est donc de la forme : 1 . 2
1
+ =
n n
u u
Cette quation peut tre rsolue par la mthode itrative :
1 . 2
1
+ =
n n
u u

1 2 2 2 1 2 2 1 ) 1 2 ( 2
2
3
2
2
2
2
+ + + = + + = + + =
n n n n
u u u u

1 2 2 1 2 2 ... 2 2
1
0
2 1
0
= = + + + + + =

n
i
n i n n
n
u u

Si on reprend la formule :
)
) (
(
1
0
=
+ =
n
i
i
n
n
a
i f
u a u
et on remplace a par 2 et f(i) par 1 on trouve le mme rsultat (car
la somme dune suite gomtrique=u0(q
n
-1)/(q-1) )
1 2 ) 1
2
1
( 2 )
2
1
( 2
0 1
0
= = + =

= =
n
n
i
i
n
n
i
i
n
n
u u

12.6 - Equation de rcurrence linaire sans second membre
Une quation de rcurrence est dite sans second membre si f(n)=0
0 . ... . .
2 2 1 1
=
k n k n n n
u u u u o o o

A une telle quation, on peut associer un polynme caractristique :
k
k k k
x x x x P o o o =

... ) (
2
2
1
1

La rsolution de ce polynme nous donne m racines r
i
( avec m<=k).

La solution de lquation de rcurrence est ainsi donne par :
n
m m
n n
n
r n Q r n Q r n Q u ) ( ... ) ( ) (
2 2 1 1
+ + + =

Cette solution est en gnral exponentielle.

Exemple :
Reprenons lexemple de la suite de Fibonacci. Son cot est donn par :
2
1
0
) 2 ( ) 1 ( 1
0
0
) (
>
=
=
+ +
=
n si
n si
n si
n T n T
n T

En posant : 1 ) ( ) ( + = n T n S on obtient :
2
1
0
) 2 ( ) 1 (
1
1
) (
>
=
=
+
=
n si
n si
n si
n S n S
n S

Donc une quation de rcurrence sans second membre.
0 ) 2 ( ) 1 ( ) ( = n S n S n S

Son polynme caractristique est : 0 1
2
= x x
Il possde deux racines :
2
5 1
2
5 1 +
et

La solution de lquation de rcurrence est donc :
n n
b a n S
|
|
.
|
\
|

+
|
|
.
|
\
|
+
=
2
5 1
2
5 1
) (

Les coefficients a et b peuvent tre dtermins laide des conditions aux limites :
2
5 ) (
2
1 ) 1 (
1 ) 0 (
b a b a
S
b a S
+
+
= =
+ = =

do :
10
5 5
10
5 5
=
+
= b et a

et enfin :
n n
n S
|
|
.
|
\
|

+
|
|
.
|
\
|
+ +
=
2
5 1
10
5 5
2
5 1
10
5 5
) (

Donc :
|
|
.
|
\
|
|
|
.
|
\
|
+
O = =
n
n T n S
2
5 1
) ( ) (

Exemple-2 :
Soit la suite dfinie par :

= =
> + =

1 0
2 4 3
1 0
2 1
u et u
n si u u u
n n n

Son polynme caractristique est :
4 3 ) (
2
= x x x P

Ses racines sont : 1 4
2 1
= = r et r
La solution de lquation de rcurrence est donc :
n n
n
b a u ) 1 ( 4 + =

Les conditions aux limites donnent :
5
1
5
1
1 4 ) 1 (
0 ) 0 (
= =
)
`
= =
= + =
b et a
b a u
b a u

do : ) 4 ( ) ) 1 ( 4 (
5
1
) (
n n n
n u O = =

12.7 - Rsolution des rcurrences diviser pour rgner
Thorme 1 (Rsolution des rcurrences diviser pour rgner ).
Soient a >=1 et b > 1 deux constantes, soit f (n) une fonction et soit T(n) une fonction
dfinie pour les entiers positifs par la rcurrence :
) ( ) / ( . ) ( n f b n T a n T + =

T(n) peut alors tre borne asymptotiquement comme suit :
Si la forme de f(n) est : Alors le cot est :
1
) ( ) (
) (log c
O =
a
b
n n f
pour un c > 0
) ( ) (
log a
b
n n T O =

2
) ( ) (
log a
b
n n f O =

) log ( ) (
log
n n n T
a
b
O =

3
) ( ) (
) (log c +
O =
a
b
n n f
pour un c > 0,
et
) ( ) / ( n cf b n af s

pour un c < 1 et n suffisamment grand
)) ( ( ) ( n f n T O =

Version-2 du thorme
) ( ) / ( . ) ( n f b n T a n T + =
ou
k
n c b n T a n T . ) / ( . ) ( + =

Si on a : Alors le cot est :
1
k
b a >

) ( ) (
log a
b
n n T O =

2
k
b a =

) log ( ) ( n n n T
k
O =

3
k
b a <

) ( ) (
k
n n T O =

Signification intuitive du thorme :
Dans chaque cas, on compare
a
b
n avec n f
log
) (
. La solution de la rcurrence est
dtermine par la plus grande des deux.

Exemple-1 : Retour sur lexemple de la multiplication de matrices :

La relation de rcurrence est : T(n) = 8T(n/2)+O(n
2
)

Donc : a = 8,
b = 2 logb a = 3
f (n) = O(n
2
) = O(n
log
b
a-1
)
On est donc dans le cas 1 du thorme (avec c = 1), lalgorithme a donc une
complexit en O(n
3
)

Exemple-2 :
n
n
T n T +
|
.
|
\
|
=
3
9 ) (

On est dans le cas : a=9 , b=3 et f(n)=n
) (
2 2 9 log log
3
n n n n
a
b
O = = = 1 ) (
9 log 1 2
3
= = = =

c
c
avec n n n n f
On applique le cas 1 :
) ( ) (
2
n n T O =

Exemple-3 :
1
3
2
) ( +
|
.
|
\
|
=
n
T n T

On est dans le cas : a=1 , b=3/2 et f(n)=1
1
1 log
log
2
3
= = n n
a
b

) ( ) (
log a
b
n n f O =

On applique donc le cas 2 :
) (log ) log ( ) (
. log
n n n n T
a
b
O = O =

Exemple-4 :
n n
n
T n T log
4
3 ) ( +
|
.
|
\
|
=

On est dans le cas : a=3 , b=4 et f(n)=nlogn
) (
793 , 0 3 log log
4
n n n
a
b
O = = 2 . 0 ) ( ) (
3 log
4
~ O =
+
c
c
avec n n f
Pour n suffisamment grand on a :
4
3
) ( . log
4
3
4
log
4
3
4
= = s
|
.
|
\
|
=
|
.
|
\
|
c avec n f c n n
n n n
af

On applique donc le cas 3 :
) log ( ) ( n n n T O =

12.8 - Autres rcurrences :
Dautres rcurrences peuvent ne pas trouver de solution avec les techniques
prsentes. Dans ce cas, on peut procder par itration :
- calculer les quelques premires valeurs de la suite
- chercher une rgularit
- poser une solution gnrale en hypothse
- la prouver par induction

13- Pourquoi estimer la complexit dun algorithme ?
Considrons lexemple de la suite de Fibonacci, et crivons deux programmes
diffrents : un rcursif et lautre non rcursif.

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

Si on suppose quune opration daddition ncessite 100ns, alors, pour calculer
Fibo(n), on obtient les rsultats suivants :

Nb-additions Nb-Secondes
n
Non
Rcursif Rcursif
Non
Rcursif Rcursif Rcursif
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 annes

Cot thorique = (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 rcursivit
il faut estimer la complexit de son algorithme

Chap-4 : Algorithmes de Tri

14- Tri par slection
Principe :
Le tri par slection est bas sur lide suivante : Slectionner le minimum ou le
maximum et le dplacer au dbut 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 linaire
Principe :
Le tri par insertion est bas sur les principes suivants : dans le tableau insrer, on
suppose quune partie a t trie et quil reste trier lautre partie. La partie trie est
appele squence destination et la partie qui reste trier est appele squence
source
a
1
, a
2
, a
3
, .. a
i-1
, a
i
, a
i+1
,.. a
n

squence destination squence source
( trie) ( non trie)
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 squence destination tant ordonne, nous pouvons donc appliquer une recherche
binaire (voir chapitre problmes de recherche) ce qui acclrera 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

17- Tri bulles
Principe :
Cette mthode est base sur lide de comparer toute paire dlments adjacents et
de les permuter sils ne sont pas dans le mme ordre et rpter le processus jusqu
ce quil ny 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 mthode du tri arborescent veut mmoriser toute information obtenue lissu des
comparaisons pour lexploiter dans ltablissement de lordre final. Pour ce faire elle
construit une arborescence qui traduit la relation qui existe entre tous les lments.
Considrons lexemple suivant : Soit le tableau suivant ordonner :
44 55 12 42 94 18 6 67

Quelle est la complexit de cet
algorithme ?
44 55 12 42 94 18 6 67
44 12 18 6
12 6

6

19- Tri par fusion
19.1 - Principe
Lalgorithme de tri par fusion est construit suivant le paradigme diviser pour rgner
:

1. Il divise la squence de n nombres trier en deux sous-squences de taille n/2.
2. Il trie rcursivement les deux sous-squences.
3. Il fusionne les deux sous-squences tries pour produire la squence complte
trie.
La rcurrence se termine quand la sous-squence trier est de longueur 1

19.2 - Algorithme
La principale action de lalgorithme du tri par fusion est justement la fusion des deux
listes tries.
La fusion
Le principe de cette fusion est simple: chaque tape, on compare les lments
minimaux des deux sous-listes tries, le plus petit des deux tant llment minimal de
lensemble on le met de ct et on recommence. On conoit ainsi un algorithme
Fusionner qui prend en entre 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 tris.
Le tri
Fusionner (A, p, q, r) // Fusionner les 2 sous-tableaux A(pq) et A(q+1r)
i=p // les 2 sous tableaux sont supposs tris
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 diffrentes tapes de lalgorithme :
les initialisations ont un cot constant O(1) ;
la boucle While de fusion sexcute au plus r-p fois, chacune de ses itrations tant
de cot constant, do un cot total en O(r-p) ;
les deux boucles While compltant C ont une complexit respective au pire de q-p+1
et de r-q, ces deux complexits tant en O(r-p) ;
la recopie finale cote O(r-p+1).
Par consquent, lalgorithme de fusion a une complexit en O(r-p).

Complexit de lalgorithme de tri par fusion
lalgorithme Tri_Fusion est de type diviser pour rgner . Il faut donc tudier ses trois
phases:
Diviser : cette tape se rduit au calcul du milieu de lintervalle [p,r], sa complexit est
donc en O(1).
Rgner : lalgorithme rsout rcursivement deux sous-problmes de tailles respectives
(n/2) , do une complexit en 2T(n/2).
Combiner : la complexit de cette tape est celle de lalgorithme de fusion qui est de
O(n) pour la construction dun tableau solution de taille n.
Par consquent, la complexit du tri par fusion est donne par la rcurrence :
=
O +
O
=
on
n si
n n T
n T
sin
1
) ( ) 2 / ( 2
) 1 (
) (
Pour dterminer la complexit du tri par fusion, nous utilisons le thorme de
rsolution des rcurrences avec : a = 2 et b = 2, donc logb a = 1 et nous nous trouvons
dans le deuxime cas du thorme : f (n) = O(nlogb a) = O(n). Par consquent :
) log ( ) ( n n n T O =

Pour des valeurs de n suffisamment grandes, le tri par fusion avec son temps
dexcution en O(nlogn) est nettement plus efficace que le tri par insertion dont le
temps dexcution est en O(n
2
).


20- Tri rapide (Quicksort)
20.1 - Principe
Le tri rapide est fond sur le paradigme diviser pour rgner , tout comme le tri
fusion, il se dcompose donc en trois tapes :
Diviser : Le tableau A[p..r] est partitionn (et rarrang) en deux sous-tableaux non
vides, A[p..q] et A[q+1..r] tels que chaque lment de A[p..q] soit infrieur ou gal
chaque lment de A[q+1..r].
Lindice q est calcul pendant la procdure de partitionnement.
Rgner : Les deux sous-tableaux A[p..q] et A[q+1..r] sont tris par des appels
rcursifs.
Combiner : Comme les sous-tableaux sont tris sur place, aucun travail nest
ncessaire pour les recombiner, le tableau A[p..r] est dj 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 rgion n-1 lments et
une 1 lment.
Comme le partitionnement cote O(n) et que T(1) = O(1), la rcurrence pour le temps
dexcution est :
) ( ) 1 ( ) ( n n T n T O + =

et par sommation on obtient :
) ( ) ( ) ( ) (
2
1 1
n k k n T
n
k
n
k
O = O = O =

= =

Meilleur cas :
Le meilleur cas intervient quand le partitionnement produit deux rgions de longueur
n/2.
La rcurrence est alors dfinie par :
) ( ) 2 / ( 2 ) ( n n T n T O + =

ce qui donne daprs le thorme de rsolution des rcurrences :
) log ( ) ( n n n T O =


Complexit moyenne :
Pour avoir une complexit moyenne, on tire au hasard lindice de dpart de
partitionnement. Et on dmontre que la complexit moyenne est aussi gale :
) log ( ) ( n n n T O =

Chap-5 : Graphes et Arbres

21- Graphes
Un graphe orient G est reprsent par un couple (S, A) o S est un ensemble fini et
A une relation binaire sur S. Lensemble S est lensemble des sommets de G et A
est lensemble des arcs de G.
Il existe deux types de graphes :
- graphe orient : les relations sont orientes et on parle darc. Un arc est reprsent
par un couple de sommets ordonns.
- Graphe non orient : les relations ne sont pas orientes et on parle alors dartes.
Une arte est reprsente par une paire de sommets non ordonns.
1 2
3
5
4
1 2
3
5
4
Figure-5.1 : Exemple de graphe orient et de graphe non orient


Une boucle est un arc qui relie un sommet lui-mme. Dans un graphe non orient
les boucles sont interdites et chaque arte est donc constitue de deux
sommets distincts.

Degr dun sommet : Dans un graphe non orient, le degr dun sommet est le
nombre dartes qui lui sont incidentes. Si un sommet est de degr 0,
comme le sommet 4 de lexemple, il est dit isol.

Degr sortant dun sommet : Dans un graphe orient, le degr sortant dun sommet
est le nombre darcs qui en partent,

Degr rentrant dun sommet : le degr entrant est le nombre darcs 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 dun
sommet u un sommet v est une squence (u0,u1,, uk) de sommets
telle que u = u0, v = uk et (ui-1, ui) appartient A pour tout i. Un chemin est
lmentaire si ses sommets sont tous distincts.

Un sous-chemin p0 dun chemin p = (u0,u1, . ,uk) est une sous-squence 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
lmentaire 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 chane (u0,u1,., uk) forme
un cycle si k >= 3 et si u0 = uk. Ce cycle est lmentaire 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 relie par une chane. Les composantes connexes dun graphe
sont les classes dquivalence 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 nimporte quel autre. Les
composantes fortement connexes dun graphe sont les classes

dquivalence de sommets induites par la relation sont accessibles lun
partir de lautre . (figure-5.1a)

Sous-graphe : On dit quun 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 fort et un graphe non orient connexe
acyclique est un arbre. La figure-5.2 prsente 3 graphes : un graphe qui nest ni un
Figure-5.2 : (a) Exemple de graphe contenant un cycle. (b) Exemple darbre
1 2
3
5
4
6
7
1 2
3
5
4
6
7

arbre ni une fort car contenant un cycle (a), un graphe qui est une fort mais pas un
arbre (b) et un arbre (c).

Thorme (Proprits 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 relis par un unique chemin
lmentaire.
a-3. G est connexe, mais si une arte quelconque est te de A, le graphe rsultant
nest plus connexe.
a-4. G est connexe et 1 = S A
a-5. G est acyclique et 1 = S A
a-6. G est acyclique, mais si une arte quelconque est ajoute A, le graphe
rsultant contient un cycle.

Arbre enracin (ou arborescence): Cest un arbre dans lequel lun des sommets se
distingue des autres. On appelle ce sommet la racine. Ce sommet particulier impose
en ralit un sens de parcours de larbre et larbre se retrouve orient par lutilisation
qui en est faite.
La figure-5.3 prsente deux arbres qui ne diffrent que sils sont considrs comme
des arbres enracins.

Anctre : Soit x un noeud (ou sommet) dun arbre T de racine r. Un noeud quelconque
y sur lunique chemin allant de r x est appel anctre de x.

Pre et fils : Si (y,x) est une arc alors y est le pre de x et x est le fils de y. La racine
est le seul noeud qui na pas de pre.
Figure-5.3 : Exemple de graphe diffrencis par la racine
3
75
80
90
12
30
60
30
80
90
60
12
3
75


Feuille ou nud externe (ou terminal) : Un noeud sans fils est un noeud terminal ou
une feuille. Un noeud qui nest pas une feuille est un nud interne. Si y est un
anctre de x, alors x est un descendant de y.

Sous-arbre : Le sous-arbre de racine x est larbre compos des descendants de x,
enracin en x.
Degr dun nud : Le nombre de fils du noeud x est appel le degr de x. Donc,
suivant quun arbre (enracin) est vu comme un arbre (enracin) ou un graphe, le
degr de ses sommets na pas la mme valeur.

Profondeur dun nud : La longueur du chemin entre la racine r et le noeud x est la
profondeur de x.

Profondeur de larbre : cest la plus grande profondeur que peut avoir un nud
quelconque de larbre. Elle est dite aussi la hauteur de larbre.

Arbre ordonn : cest un arbre enracin dans lequel les fils de chaque noeud sont
ordonns entre eux. Les deux arbres de la figure-5.4 sont diffrents si on les regarde
comme des arbres ordonns, mais ils sont identiques si on les regarde comme de
simples arbres (enracins).

Figure-5.4 : Exemple darbres (enracins) qui ne diffrent que sils sont ordonns
3
75
80
90
12
30
60
75
80
90
60
30
12
3


23- Arbre binaire :
Un arbre binaire est tel que chaque nud a au plus deux fils.
Les arbres binaires se dcrivent plus aisment de manire rcursive. Un arbre binaire
T est une structure dfinie 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 na quun seul fils, la position de ce filsquil soit
fils gauche ou fils droitest importante.

Arbre binaire complet : Dans un arbre binaire complet chaque noeud est soit une
feuille, soit de degr deux. Aucun noeud nest donc de degr un.
Un arbre k-aire est une gnralisation de la notion darbre binaire o chaque noeud
est de degr au plus k et non plus simplement de degr au plus 2.

24- Parcours dun graphe
24.1 - Parcours des arbres
Nous ne considrons ici que des arbres ordonns. Les parcours permettent
deffectuer tout un ensemble de traitement sur les arbres.
24.1.1 Parcours en profondeur
Dans un parcours en profondeur, on descend dabord le plus profondment possible
dans larbre puis, une fois quune feuille a t atteinte, on remonte pour explorer les
autres branches en commenant par la branche la plus basse parmi celles non
encore parcourues. Les fils dun noeud sont bien videmment parcourus suivant
lordre sur larbre.
Algorithme ParPro(A)
If A nest pas rduit 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
visits avant que le premier noeud la profondeur i+1 ne soit visit. Un tel parcours
ncessite lutilisation dune file dattente pour se souvenir des branches qui restent
visiter.


Algorithme Parcours_Largeur(A)
F : File dattente
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 indfiniment ces
cycles. Pour cela, il suffit de colorier les sommets du graphe.
- Initialement les sommets sont tous blancs,
- lorsquun sommet est rencontr pour la premire fois il est peint en gris,
- lorsque tous ses successeurs dans lordre de parcours ont t visits, il est
repeint en noir.

Algorithme PP(G)
for chaque sommet u de G do
couleur[u]=Blanc
endfor
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.1 Parcours en profondeur

24.2.2 Parcours en largeur
Dans un parcours en largeur dabord,
tous les noeuds une
profondeur i doivent avoir t visits
avant que le premier noeud la
profondeur i+1 ne soit visit. Un tel
parcours ncessite lutilisation dune
file dattente pour se souvenir des
branches qui restent visiter.

Algorithme PL(G, s)
F : File dattente
couleur[u] = Blanc
Endfor
couleur[s]=Gris
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

Data Left Right
Chap-6 : Arbres Binaires et Arbres Binaires de
Recherche

25- Dfinition
Un arbre ou arborescence binaire est un graphe qui admet une racine et sans cycle et
dont chaque nud admet deux fils : fils droit et fils gauche.
On peut reprsenter un arbre binaire sous la forme dune liste chane mais non
linaire.
26- Implmentation dun arbre binaire :
26.1 - Dfinition des structures de donnes :
Chaque nud sera compos de 3 champs : un champ pour la donne, et deux
champs pointeurs lun pour le fils droit et lautre pour le fils gauche. La structure de
donne arbre contient un seul pointeur racine qui donne le premier lment de
larbre.

Struct node
{ type data ;
struct node *left ;

struct node *right;
};
struct arbre
{ struct node *racine ; } ;

26.2 - Parcours dun arbre binaire:
Il existe 3 mthodes de parcours dun arbre binaire :
- parcours prfixe : pre, fils gauche, fils droit
- parcours infixe : fils gauche, pre, fils droit
- parcours postfixe : fils gauche, fils droit, pre

On ne peut raliser ces diffrents parcours quen utilisant une pile, puisquon est oblig
de commencer le parcours par la racine et dempiler les nuds dont on na pas encore
rencontr le fils gauche. La pile peut tre utilise dune manire explicite ou bien au
moyen dune procdure rcursive.

26.2.1 Parcours prfixe :
Lalgorithme rcursif et son implmentation en C de ce parcours sont donns dans le
tableau suivant :

Algorithme Programme en C
Algorithme Prfixe(struct node
A)
If (A != Nil) then
AfficheRacine(A)
Prfixe (FilsGauche(A))
Prfixe (FilsDroit(A))
End_If
End_Prfixe
Void PrfixeArbre (struct arbre *a)
{ Prfixe (a -> racine) ; }

void Prfixe ( struct node *pere)
{ if (pere != null)
{ /* traiter la donne pere -> data */
Prfixe ( pere -> left);
Prfixe (pere -> right) ;
}
}

26.2.2 Parcours infixe :
tableau suivant :

Algorithme Infixe(A)
If (A != Nil) then

Infixe (FilsGauche(A))
AfficheRacine(A)
Infixe (FilsDroit(A))
End_If
End_Prfixe
Void InfixeArbre (struct arbre *a)
{ Infixe (a -> racine) ; }

void Infixe ( struct node *pere)
{ if (pere != null)
{ Infixe ( pere -> left);
/* traiter la donne pere -> data */
Infixe (pere -> right) ;
}
}

26.2.3 Parcours postfixe :
tableau suivant :

Algorithme Postfixe(A)
If (A != Nil) then
Postfixe (FilsGauche(A))
Postfixe (FilsDroit(A))
AfficheRacine(A)
End_If
End_Prfixe
Void PostfixeArbre (struct arbre *a)
{ Postfixe (a -> racine) ; }

void Postfixe ( struct node *pere)
{ if (pere != null)
{ Postfixe ( pere -> left);
Postfixe (pere -> right) ;
/* traiter la donne pere -> data */
}
}

26.2.4 Parcours infixe dun arbre en utilisant une pile :
Le programme suivant est une version drcursive utilisant une pile explicite et
permettant le parcours infixe dun arbre binaire.

void parcourir_infixe ( struct arbre *a) /* en utilisant une pile */
{ struct pile pl ; /* le type des lments 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 donne 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 nud est
suprieur son fils gauche et infrieur son fils droit et il ny a pas de nuds gaux.

Un arbre binaire de recherche est intressant puisquil est toujours possible de
connatre dans quelle branche de larbre se trouve un lment et de proche en proche
le localiser dans larbre. On peut aussi utiliser un arbre binaire de recherche pour
ordonner une liste dlments.

3
75
80
90
12
30
60


Pour utiliser un arbre binaire de recherche il va falloir rsoudre trois problmes :

- Comment permettre la multiplicit des lments ?
Solution : Ajouter un champ dans le nud pour indiquer la frquence de la valeur.
- Comment construire un arbre binaire de recherche ou comment insrer un nouvel
lment dans larbre ?
Solution : Il faut descendre dans larbre jusqu trouver un pointeur gal Null.
- Comment retrouver lordre des lments ?
Solution : Effectuer un parcours infixe.

Exemple : Construisons un arbre binaire de
recherche pour la squence de valeurs
suivantes : 75, 30, 60, 12, 80, 3, 90
Application : Lire une liste de notes dans le
dsordre, construire un arbre binaire de
recherche et imprimer les notes dans lordre
croissant.

3
75
80
90
12
30
60


26.3.1 Algorithme de recherche dun lment :
La recherche dun lment dans un arbre binaire de recherche est trs facile si on
profite du caractre rcursif dun arbre binaire.

Algorithme Chercher (Parent P , lment 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 dinsertion dun lment :
Llment ajouter est insr l o on laurait trouv sil avait t prsent dans larbre.
Lalgorithme dinsertion recherche donc llment dans larbre et, quand il aboutit la
conclusion que llment nappartient pas larbre (il aboutit la terre), il insre
llment comme fils du dernier noeud visit.

Algorithme Insrer (Parent P, lment X)
If (P = null)
ajouter un nud pour X cet endroit
else
If (P.data = X)
Incrmenter nombre dexemplaires
Else
If(X> P.data)
Insrer (P.Fils droit, X)

Else
Insrer (P.Fils gauche, X)
EndInsrer

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 dun lment :
La suppression dun lment est plus complique que linsertion, car si cet lment est
un pre qui confier ses fils ?
Il existe trois cas possibles :

1
er
cas : llment supprimer na pas de fils il est terminal et il suffit de le
supprimer

15
16
20
18 23
3
5
12
10 13
4
6
15
16
20
18 23
3
5
12
10
6

2
me
cas : llment a un fils unique on supprime le nud et on relie son fils son
pre
15
16
20
18 23
3
5
12
10 13
4
6
7
15
20
18 23
3
5
12
10
6
7
13


3
me
cas : llment supprimer a deux fils on le remplace par son successeur qui
est toujours le minimum de ses descendants droits.

15
16
20
18 23
3
5
12
10 13
4
6
7
15
16
20
18 23
3
6
12
10 13
4
7


26.3.4 Complexit :
Si h est la hauteur de larbre, on peut aisment montrer que tous les algorithmes
prcdents 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 sintresse des arbres de
recherches quilibrs.
15
3
6
12
25
17 35
3
6
12
15
17
25
35


26.4 - Arbre Rouge et Noir :
Un arbre rouge et noir est un type
darbres de recherche dits presque
quilibrs.
26.4.1 Dfinition
Un arbre binaire de recherche est un
arbre rouge et noir sil satisfait les
proprits 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 mme nombre de noeuds noirs.

7
2 1
1
8 1
4
5 1
4 1
5
Nul
l
Nul
l
Nul
l
Nul
l
Nul
l
Nul
l
Nul
l
Nul
l
Nul
l
Nul
l

Dfinition : On appelle hauteur noire dun noeud x le nombre de noeuds noirs sur un
chemin descendant de x une feuille.

Mise jour dun arbre rouge et noir
Les oprations de mise jour dun arbre rouge et noir sont un peu plus
compliques que dans le cas dun arbre binaire classique car il faut veiller ne pas
violer les rgles que doit vrifier un arbre rouge et noir .
Pour cela, on aura besoin de changer la couleur des nuds et deffectuer des
dplacements appels rotations .

26.4.2 Rotations
Pour prserver les proprits dun arbre binaire de recherche rouge et noir lors de
la mise jour, on aura besoin deffectuer des rotations :

y
x
C
B
A
y
x
A B
C
Rotation droite (y)
Rotation gauche (y)
(y)


26.4.3 Insertion
Pour insrer un nouvel lment dans un arbre rouge et noir :
- insrer llment normalement comme dans un arbre binaire de recherche
normal
- colorier le nud en rouge car le noir provoquerait une violation de la 4
me

proprit de larbre rouge et noir
- dtecter les ventuels cas pathologiques qui violent les proprits
- effectuer les transformations ncessaires (rotations)

26.4.4 Suppression
Pour supprimer un lment dans un arbre rouge et noir :
- appliquer lalgorithme de suppression dans un arbre binaire de recherche
- Si llment supprim est de couleur rouge pas de problme : aucune
proprit nest viole
- Par contre si le nud supprim est noir, la 4
me
proprit est viole. Il faudra
dans ce cas tudier les pathologies et apporter les modifications ncessaires.


26.4.5 Complexit :
Thorme : Un arbre rouge et noir contenant n nuds internes a une hauteur au
plus gale 2.log(n+1)

On peut montrer par induction que le sous-arbre (dun 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 infrieure au double de la
hauteur noire on en dduit la borne donne par le thorme.

Ce thorme montre bien que les arbres rouge et noir sont relativement quilibrs : la
hauteur dun arbre rouge et noir est au pire le double de celle dun arbre binaire
parfaitement quilibr.

Toutes les oprations sur les arbres rouge et noir sont de cot O(h), cest--dire
O(logn), ce qui justifie leur utilisation par rapport aux arbres binaires de recherche
classiques.


Algo Avancée (Notes de Hamrouni)

Transféré par

Informations du document

Description :

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é ?

Description :

Droits d'auteur :

Formats disponibles

Algo Avancée (Notes de Hamrouni)

Transféré par

Description :

Droits d'auteur :

Formats disponibles

Notes de cours : Algorithmique & Complexit 1/140 Hamrouni Kamel

Chap-1 : Introduction & motivations

Vous aimerez peut-être aussi