1. Université Saad Dahleb de Blida
Faculté des Sciences
Département d’Informatique
Licence Génie des Systèmes Informatique (GSI)
Semestre 5 (3ème année)
ALGORITHMIQUE 02
CHAPITRE III:
RÉCURSIVITÉ ET PARADIGME «
DIVISER POUR RÉGNER »
Cours n°3: 20 Octobre 2013
AROUSSI Sana
Disponible sur https://sites.google.com/a/esi.dz/s-aroussi/

2. PLAN DU CHAPITRE III
 Partie
1: La récursivité
 Partie
2: La dérécursivation
 Partie
3: La paradigme « Diviser pour régner »
2

3. PARTIE1: LA RÉCURSIVITÉ

4. PLAN DE LA PARTIE I
 Définitions
 Évolution
 Types
d’un appel récursif
de la récursivité
 Récursivité
terminale vs non terminale
 Complexité
des algorithmes récursifs
 Écrire
un algorithme récursif
 Exemple:
Tours de Hanoi
4

5. DÉFINITIONS

Un algorithme est dit récursif s'il est défini en fonction de
lui-même.

Exemple : la factorielle n!
Itératif
n! = 1 * 2 * ... * n
Facto (n: entier): entier
Début
F1;
Pour i2 à n faire
FF*i;
retourne F;
Fin
Récursif
n! = n * (n-1)!
Facto (n: entier): entier
Début
retourne n*Facto (n-1);
Fin
5

6. ÉVOLUTION D’UN APPEL RÉCURSIF

L'exécution d'un appel récursif passe par deux phases, la
phase de descente et la phase de la remontée :

Dans la phase de descente, chaque appel récursif fait à son tour
un appel récursif.

Exemple : 4! = Facto(4)
Facto(4)  4 * Facto(3)
Facto(3)  3 * Facto(2)
Facto(2)  2 * Facto(1)
Facto(1)  1 * Facto(0)
6
Facto(4)  0 * Facto(-1)

7. CONDITION D’ARRÊT

Puisqu'un algorithme récursif s'appelle lui-même, il est impératif
qu'on prévoit une condition d'arrêt à la récursion, sinon le
programme ne s'arrête jamais!

Exemple : la factorielle n!
Version précédente
Facto (n: entier): entier
Début
retourne n*Facto (n-1);
Fin
Version correcte
Facto (n: entier): entier
Début
Si (n=1) alors retourne 1
Sinon retourne n*Facto (n-1);
Fin
7

8. ÉVOLUTION D’UN APPEL RÉCURSIF

En arrivant à la condition terminale, on commence la phase de la
remontée qui se poursuit jusqu'à ce que l'appel initial soit terminé,
ce qui termine le processus récursif.
Exemple :
24
Facto(4)  4 * Facto(3)
6
Facto(3)  3 * Facto(2)
1
2
Facto(2)  2 * Facto(1)
Phase de la remontée

8

9. TYPES DE RÉCURSIVITÉ
1. La récursivité simple où l’algorithme contient un seul appel
récursif dans son corps.

Exemple : la fonction factorielle
Facto (n: entier): entier
Début
Si (n=1) alors retourne 1
Sinon retourne n*Facto (n-1);
Fin
9

10. TYPES DE RÉCURSIVITÉ
2. La récursivité multiple où l’algorithme contient plus d'un appel
récursif dans son corps

Exemple : le calcul du nombre de combinaisons en se servant de la
relation de Pascal :
10

11. TYPES DE RÉCURSIVITÉ
3. La récursivité mutuelle: Des modules sont dits mutuellement
récursifs s’ils dépendent les unes des autres

Exemple : la définition de la parité d'un entier peut être écrite de la
manière suivante :
11

12. TYPES DE RÉCURSIVITÉ
4. La
récursivité imbriquée consiste à faire un appel récursif à
l'intérieur d'un autre appel récursif.

Exemple : La fonction d'Ackermann
12

13. RÉCURSIVITÉ TERMINALE VS NON TERMINALE

Un module récursif est dit terminal si aucun traitement n'est effectué
à la remontée d'un appel récursif (sauf le retour du module).

Un module récursif est dit non terminal si le résultat de l'appel
récursif est utilisé pour réaliser un traitement (en plus du retour du
module).
Récusivité non terminale
Facto (n: entier): entier
Début
Si (n=1) alors
retourne 1
Sinon
retourne n*Facto (n-1);
Fin
Récursivité Terminal
Facto (n: entier, resultat: entier): entier
Début
si (n = 1) alors
retourne resultat;
sinon
retourne Facto (n-1, n * resultat);
Fin
13
// la fonction doit être appelée en mettant
resultat à 1

14. RÉCURSIVITÉ TERMINALE VS NON TERMINALE
Facto(4,1)  Facto(3, 4*1)
Facto(3, 4)  Facto(2, 3*4)
Facto(2, 12)  Facto(1, 2*12)
Facto(1, 24)
14

15. COMPLEXITÉ DES ALGORITHMES RÉCURSIFS

La complexité d’un algorithme récursif se fait par la résolution
d’une équation de récurrence en éliminant la récurrence par
substitution de proche en proche.

Exemple : la fonction factorielle (T(n) le temps d’exécution nécessaire pour un
appel à Facto(n))
Facto (n: entier): entier
Début
Si (n=1) [O (1)] alors
n=1
retourne 1 [O (1)]
Sinon
retourne n*Facto (n-1); [T (n) dépend de T(n-1)]
Fin
15

16. COMPLEXITÉ DES ALGORITHMES RÉCURSIFS

Pour calculer la solution générale de cette équation, on peut
procéder par substitution :
16
O (T) = O (n)

17. ÉCRIRE UN ALGORITHME RÉCURSIF

Dans un module récursif (procédure ou fonction) les paramètres
doivent être clairement spécifiés

Dans le corps du module il doit y avoir:

un ou plusieurs cas particuliers: ce sont les cas simples qui ne
nécessitent pas d'appels récursifs

un ou plusieurs cas généraux: ce sont les cas complexes qui sont résolus
par des appels récursifs

L'appel récursif d'un cas général doit toujours mener vers un des cas
particuliers
17

18. EXEMPLE DES TOURS DE HANOI

Déplacer n disques (empilés les uns sur les autres) d'un piquet (A)
vers un autre piquet (B) en utilisant un troisième (C) comme
intermédiaire (ce sont des piles, on ne peut accéder qu'au
disque du sommet)
un disque ne peut jamais être placé au dessus d'un autre
plus petit
18

19. EXEMPLE DES TOURS DE HANOI
CONCEPTION DE LA SOLUTION RÉCURSIVE

Il faut pouvoir exprimer :

« le déplacement de n disques » en fonction d'un ou de plusieurs «
déplacement de m disques » (avec m < n).

Par exemple (m=n-1) si on avait une solution pour déplacer n-1
disques, comment l'utiliser pour déplacer n disques ?
19

20. EXEMPLE DES TOURS DE HANOI
CONCEPTION DE LA SOLUTION RÉCURSIVE
20

21. EXEMPLE DES TOURS DE HANOI
ALGORITHME INFORMEL

Pour Transférer n disques de A vers B avec C comme intermédiaire,
il faut :

Cas particulier (n = 1)


déplacer le disque de X vers Y.
Cas général (n > 1)

Transférer les n-1 premiers disques de A vers C, en utilisant B
comme intermédiaire

déplacer l'unique disque qui reste dans A vers B

Transférer les n-1 premiers disques de C vers B, en utilisant A
comme intermédiaire
21

22. EXEMPLE DES TOURS DE HANOI
ALGORITHME FINAL

Hanoi( n:entier; A,B,C : caractères )
SI ( n = 1 )
écrire(« déplacer un disque de », A, « vers », B );
SINON
Hanoi ( n-1, A, C, B );
écrire(« déplacer un disque de », A, « vers », B );
Hanoi( n-1, C, B, A );
FSI
22

23. EXEMPLE DES TOURS DE HANOI
AUTRE VERSION

Hanoi( n:entier; A,B,C : caractères )
SI ( n > 0 )
Hanoi ( n-1, A, C, B );
écrire(« déplacer un disque de », A, « vers », B );
Hanoi( n-1, C, B, A );
FSI
23

24. EXEMPLE DES TOURS DE HANOI
COMPLEXITÉ

Hanoi( n:entier; A,B,C : caractères ) [T(n)]
SI ( n > 0 )
Hanoi ( n-1, A, C, B ); [T(n-1)]
écrire(« déplacer un disque de », A, « vers », B ); [O(1)]
Hanoi( n-1, C, B, A ); [T(n-1)]
FSI
T(n) = 2*T(n-1) + a = 2 *(2*T(n-2) + a)+ a = 2*2T(n-2)+ 2a+ a
= ........
= 2n T(0) + (20+21+22+.......+ 2n-1) a
= 2n 0 + (2n -1) a
O (T) =
2n
24

25. PARTIE 2:
LA DÉRÉCURSIVATION
Cours n°4: 23 Octobre 2013

26. PLAN DE LA PARTIE II
 Généralités
 Élimination
de la récursivité terminale simple
 Élimination
de la récursivité terminale multiple
 Élimination
de la récursivité non terminale simple
 Élimination
de la récursivité: Algorithme Général
26

27. GÉNÉRALITÉS

Au niveau de l’utilisateur: la récursivité permet d’écrire
des algorithmes concis et élégants.

Au niveau de la machine: le compilateur élimine toujours
la
récursivité
programme
(Dérécursiver)
itératif
(ensemble
en
construisant
des
un
instructions
séquentielles) afin d’économiser l'espace de la pile
d'exécution.

Dérécursiver, c’est transformer un algorithme récursif
en un algorithme itératif équivalent ne contenant pas des
appels récursifs.
27

28. ÉLIMINATION DE LA RÉCURSIVITÉ

TERMINALE
SIMPLE
Rappel: Un algorithme est dit récursif terminal s’il ne
contient aucun traitement après un appel récursif.
Procédure ALGO (X) // Liste des paramètres
Si (COND) alors
TRAIT1
// Condition portant sur X
// Traitement de base de l’algorithme (dépendant de X)
ALGO (B(X))
// B(X) représente la transformation des paramètres
Sinon
TRAIT2
// Traitement de terminaison (dépendant de X)
Fsi
28

29. ÉLIMINATION DE LA RÉCURSIVITÉ
TERMINALE
SIMPLE
Algorithme Récursif
Algorithme Itératif
Procédure ALGO-R (X)
Procédure ALGO-I (X)
Début
Début
Si (COND) alors
Tant que (COND) faire
TRAIT1
TRAIT1
ALGO-R (B(X))
X B(X)
Sinon
TRAIT2
Fsi
FTQ
TRAIT2
Fin
Fin
29

30. ÉLIMINATION DE LA RÉCURSIVITÉ TERMINALE SIMPLE
EXEMPLE: FACTORIELLE
Algorithme Récursif
Algorithme Itératif
Fonction Facto-R (n, resultat)
Fonction Facto-I (n, resultat)
Début
Début
Si (n>1) alors
Resultat1
Retourner (Facto-R (n-1, n * resultat))
Tant que (n>1) faire
Sinon
Retourner (resultat)
résultat n * resultat
n  n-1
Fsi
FTQ
Fin
Retourner (resultat)
Fin
30

31. ÉLIMINATION DE LA RÉCURSIVITÉ TERMINALE MULTIPLE
EXEMPLE: PGCD

Écrire une fonction récursive permettant de calculer le PGCD (Plus
Grand Commun Diviseur) de deux nombres naturels non nul (a, b) en
utilisant l’algorithme d’Euclide:
31

32. ÉLIMINATION DE LA RÉCURSIVITÉ TERMINALE MULTIPLE
EXEMPLE: PGCD
Algorithme Récursif
Algorithme Itératif
Fonction PGCD-R (a, b)
Fonction PGCD-R (a, b)
Début
Début
Si (a = b) alors Retourner (a)
Tant que (ab) faire
Sinon // ab
Si (a>b) alors
Retourner (PGCD-R (a-b, b))
Sinon
Retourner (PGCD-R (a, b-a))
Fsi
Fin
Si (a>b) alors aa-b
Sinon bb-a
FTQ
Retourner (a)
Fin
32

33. ÉLIMINATION DE LA RÉCURSIVITÉ NON TERMINALE SIMPLE

Dans un algorithme récursif non terminal, l’appel récursif est
suivi d’un traitement  Il reste un traitement (TRAIT2) à
reprendre après l’appel récursif
Procédure ALGO (X) // Liste des paramètres
Si (COND) alors
TRAIT1
// Traitement de base de l’algorithme (dépendant de X)
ALGO (B(X))
TRAIT2
// Condition portant sur X
// B(X) représente la transformation des paramètres
// Traitement à reprendre après le retour (dépendant de X)
Sinon
TRAIT3
Fsi
// Traitement de terminaison (dépendant de X)
33

34. ÉLIMINATION DE LA RÉCURSIVITÉ NON TERMINALE SIMPLE

Il faut donc sauvegarder le contexte de l’appel récursif
(typiquement les paramètres de l’appel engendrant l’appel
récursif) sur une pile

Les piles sont des structures de stockage qui fonctionnent
sur le principe LIFO « last In First Out: le dernier entré
est le premier sorti»

Le principe est de simuler la pile d’appels des processus
pour éliminer la récursivité non terminale.
34

35. Algorithme Récursif
Algorithme Itératif
Procédure ALGO-R (X)
Procédure ALGO-I (X)
Début
Début
Si (COND) alors
Init(P) //Initialiser la Pile P.
TRAIT1
Tant que (COND) faire
ALGO-R (B(X))
TRAIT1
TRAIT2
Empiler(P, X)
Sinon
TRAIT3
Fsi
Fin
X B(X)
FTQ
TRAIT3
Tant que (Non Vide (P)) Faire
Dépiler(P, U)
TRAIT2
FTQ
Fin
35

36. ÉLIMINATION DE LA RÉCURSIVITÉ NON TERMINALE SIMPLE
EXEMPLE: FACTORIELLE
Algorithme Récursif
Fonction Facto-R (N)
Algorithme Itératif
Fonction ALGO-I (N)
Début
Début
Si (n>1) alors
Init(P) //P contient la valeur de N.
Y  N * Facto-R (N-1)
Sinon
Y1
Tant que (n>1) faire
Empiler(P, N)
N N-1
Fsi
FTQ
Facto-RY;
Y1
Fin
Tant que (Non Vide (P)) Faire
Dépiler(P, U)
Y Y * U
FTQ
Facto-RY;
Fin
36

37. ÉLIMINATION DE LA RÉCURSIVITÉ
ALGORITHME GÉNÉRAL
1. Définir la zone de données
•Contient les paramètres, l’adresse du retour et les variables locales.
2. Définir les points d'appel et de retour.
•Il y a donc toujours un appel dans l'algorithme appelant. C'est le premier appel.
3. Appel de la procédure
•3.1. Empiler la zone de données courante.
•3.2. Préparer le nouvel appel en préparant la nouvelle zone de données avec les
paramètres (passage de paramètres) et avec l'adresse de retour (point d'appel).
•3.4. Se brancher vers le début de la fonction.
4. Retour de la procédure
•4.1. Récupérer l'adresse de retour qui se trouve dans la zone de données courante.
•4.2. Dépiler une zone de donnée (restaurer la dernière sauvegardée)
•4.3. Se brancher vers cette adresse.
37

38. ÉLIMINATION DE LA RÉCURSIVITÉ
EXEMPLE: LES TOURS DE HANOI
1. Soit Z la zone de données, Z = [n, S, D, I, @retour]
2.
Soient Et0, Et2, Et3 les points d’appel et de retour et Et1
l’adresse de début de la fonction
Programme appelant
.....
Et0:Hanoi(4,’A’,’B’,’C’);
.....
Procédure appelée
Procédure Hanoi-R ( n, S, D, I)
Et1 SI ( n > 0 )
Et2 Hanoi-R ( n-1, S, I, D );
écrire(SD );
Et3 Hanoi-R ( n-1, I, D, S );
FSI
38

39. ÉLIMINATION DE LA RÉCURSIVITÉ
EXEMPLE: LES TOURS DE HANOI
Prog. appelant
Et0:Hanoi(4,’A’,’B’,’C’);
//suite du prog
CreerPile(P);
Empiler(P,Z);
Z.n4; Z.S  ‘A’; Z.D ‘C’; Z.I ‘B’; Z.@Et0;
goto Et1;
Et0: suite du prog
Proc Hanoi-R ( n, S, D, I)
/*Traduction de la procédure*/
Et1 SI ( n > 0 )
Et1: SI ( Z.n > 0 )
Et2 Hanoi-R ( n-1, S, I, D );
Empiler(P,Z)
Z.nZ.n-1; TZ.D; Z.DZ.I; Z.IT; Z.@Et2;
goto Et1;
écrire(SD );
Et2: écrire(Z.SZ.D );
Et3 Hanoi-R ( n-1, I, D, S );
Empiler(P,Z)
Z.nZ.n-1; TZ.S; Z.SZ.I; Z.IT; Z.@Et3;
goto Et1;
FSI
Et3: FSI
Fin
TmpZ.@;
Depiler(P,Z);
goto tmp
39

40. ÉLIMINATION DE LA RÉCURSIVITÉ
EXEMPLE: LES TOURS DE HANOI

Amélioration: Peut on éliminer les goto???
CreerPile(P); Empiler(P,Z); Z.n4; Z.S ‘A’; Z.D ‘C’; Z.I ‘B’; Z.@Et0;
Allera Et1;
Et1: SI ( Z.n > 0 )
1 Empiler(P,Z); Z.n:=Z.n-1; T:=Z.D;Z.D:=Z.I;Z.I:=T;Z.@=Et2;
goto Et1;
Et2: écrire(Z.SZ.D );
2
Empiler(P,Z) Z.n:=Z.n-1; T=Z.S; Z.S:=Z.I; Z.I:=T; Z.@=Et3;
goto Et1;
Et3: FSI
3
Répéter
Tmp:=Z.@; Depiler(P,Z);
Jusqu’à tmp!=Et3;
Si tmp = Et2
Équivalente à non pile vide
alors goto Et2;
Sinon allera Et0;
Et0: suite du prog
40

41. CONCLUSION

Les programmes itératifs sont souvent plus efficaces,
mais les programmes récursifs sont plus faciles à écrire.

Les
compilateurs
savent,
la
plupart
du
temps,
reconnaître les appels récursifs terminaux, et ceux-ci
n’engendrent pas de surcoût par rapport à la version
itérative du même programme.

Il est toujours possible de dérécursiver un algorithme
41
récursif.

42. PARTIE 3: DIVISER POUR
RÉGNER
Cours n°5: 23 Octobre 2013

43. PLAN DE LA PARTIE III

Principe

Complexité des Algorithmes « Diviser pour
Régner »
43

44. PRINCIPE

La récursivité est un outils puissant permet de concevoir des
solutions
(simples)
sans
se
préoccuper
des
détails
algorithmiques internes

Paradigme Diviser pour Régner: spécifier la solution du
problème en fonction de la (ou des) solution(s) d'un (ou de
plusieurs) sous-problème plus simple(s).

Comment trouver la solution d'un sous-problème ?

Ce n'est pas important car on prendra comme hypothèse que
chaque appel récursif résoudra un sous-problème

Si on arrive à trouver une solution globale en utilisant ces
hypothèses, alors ces dernières (hypothèses) sont forcément
correctes, de même que la solution globale  Cela ressemble à44
la
« démonstration par récurrence »

45. Combiner
Régner
Diviser
PRINCIPE
Problème
Global
Sous
Problème
1
Sous
Problème
2
Décomposer le problème en k
sous
problème
de
taille
moindre
Sous
Problème
K
Chaque sous problème sera résolu par la même décomposition récursive
....jusqu’à l’obtention de sous problèmes triviaux
Sous
Solution
1
Sous
Solution
2
Solution
Globale
Sous
Solution
K
Combinaison
obtenues
des
solutions
45

46. EXEMPLE 1 : RECHERCHE MAXIMUM

Soit Tab un tableau à n éléments, écrire une fonction
récursive permettant de rechercher de l’indice du
maximum dans Tab en utilisant le paradigme diviser
Régner
Diviser
pour régner
5
5
8
1
8
5
10
1
10
1
8
8
10
10
46
Combiner
10

47. EXEMPLE 1 : RECHERCHE MAXIMUM
Fonction maximum ( Tab , indDeb, indFin)
T(n)
Si ( indDeb = indFin) alors retourner (indDeb)
Sinon
M(indDeb+indFin)/2 // division du problème en 2 sous-problèmes
T(n/2)
k1  maximum (Tab, indDeb, m ) // régner sur le 1er sous-problème
k2 maximum (Tab, m+1, indFin) // régner sur le 2ème sous-problème
T(n/2)
// Combiner les solutions
Si (Tab[k1] > Tab[k2]) alors retourner (k1)
Sinon retourner (k2)
Fsi
Fsi
Fin
T(n) = 2 T(n/2) + c
47

48. EXEMPLE 2 : RECHERCHE DICHOTOMIQUE

Soit Tab un tableau trié (ordre croissant) à n éléments.

La recherche par dichotomie compare l‘élément cherché x avec
l‘élément en position m situé au milieu du sous-tableau :

si Tab[m] = x : on a trouvé l‘élément en position m

si Tab[m] > x : il est impossible que x se trouve après la position
m dans le tableau. Il reste à traiter uniquement la moitié
inférieure du tableau

De même si Tab[m] < x : il reste à traiter uniquement la moitié
supérieure du tableau

On continue ainsi la recherche jusqu’à trouver l’élément ou bien
aboutir sur un tableau de taille nulle, x n'est pas présent et la
recherche s'arrête.
48

49. EXEMPLE 2 : RECHERCHE DICHOTOMIQUE
Fonction RechDicho(Tab :Tableau, borneinf :entier, bornesup :entier, x :entier) : bool
Si (borneinf<=bornesup) alors
T(n)
mil  (borneinf+bornesup) DIV 2 ;
Si (Tab[mil]=elem) Alors
retourner (vrai)
Sinon
Si (Tab[mil]>x) Alors Retourner (RechDicho(Tab, borneinf, mil-1, x))
Sinon
T(n/2)
Retourner(RechDicho(Tab, mil+1, bornesup, elem))
Fsi
Sinon
Retourner (Faux)
Fsi
T(n) = T(n/2) + c
49

50. COMPLEXITÉ DES ALGORITHMES « DIVISER POUR RÉGNER »

Le temps d'exécution d’un algorithme « diviser pour régner » se décompose
suivant les trois étapes du paradigme de base :

Diviser: le problème en a sous-problèmes chacun de taille 1/b de la
taille du problème initial. Soit D(n) le temps nécessaire à la division du
problème en sous-problèmes.

Régner: Soit aT (n/b) le temps de résolution des a sous-problèmes.

Combiner: Soit C(n) le temps nécessaire pour construire la solution
finale à partir des solutions aux sous-problèmes.
T(n) = a T (n/b) + D(n) + C(n)

Soit la fonction f (n) la fonction qui regroupe D(n) et C(n). La fonction T(n) est
alors définie :
50
T(n) = a.T(n / b) + f(n)

51. COMPLEXITÉ DES ALGORITHMES « DIVISER POUR RÉGNER »
THÉORÈME DE RÉSOLUTION DE LA RÉCURRENCE :

Pour f
(n) = c nk , on a : T(n) = a.T(n / b) + c nk
51

52. COMPLEXITÉ DES ALGORITHMES « DIVISER POUR RÉGNER »
EXEMPLES

Pour T(n) = a.T(n / b) + c nk, on a :

Complexité de l’algorithme de recherche du maximum:
T(n) = 2 T(n/2) + c
a = 2 , b = 2, k = 0  a > bk
T(n) = O(n)
52

53. COMPLEXITÉ DES ALGORITHMES « DIVISER POUR RÉGNER »
EXEMPLES

Pour T(n) = a.T(n / b) + c nk, on a :

Complexité de l’algorithme de recherche dichotomique:
T(n) = T(n/2) + c
a = 1 , b = 2, k = 0  a = bk
T(n) = O(log(n))
53

54. COMPLEXITÉ DES ALGORITHMES « DIVISER POUR RÉGNER »
EXEMPLES

Pour T(n) = a.T(n / b) + c nk, on a :
54

55. COMPLEXITÉ DES ALGORITHMES « DIVISER POUR RÉGNER »
EXEMPLES

Pour T(n) = a.T(n / b) + c nk, on a :
55

56. COMPLEXITÉ DES ALGORITHMES « DIVISER POUR RÉGNER »
AUTRES RÉSOLUTIONS DE RÉCURRENCE

Équations de récurrence linéaires:

Exemple : Les Tours de Hanoi
Hanoi( n:entier; A,B,C : caractères ) [T(n)]
SI ( n > 0 )
Hanoi ( n-1, A, C, B ); [T(n-1)]
écrire(« déplacer un disque de », A, « vers », B ); [cst]
Hanoi( n-1, C, B, A ); [T(n-1)]
FSI
56
T(n) = 2*T(n-1) + c avec T(0) = 0;

57. COMPLEXITÉ DES ALGORITHMES « DIVISER POUR RÉGNER »
AUTRES RÉSOLUTIONS DE RÉCURRENCE

Équations de récurrence linéaires:

Exemple : Les Tours de Hanoi
T(n) = 2*T(n-1) + c
O (T) = 2n
57

58. COMPLEXITÉ DES ALGORITHMES « DIVISER POUR RÉGNER »
AUTRES RÉSOLUTIONS DE RÉCURRENCE

Équations de récurrence linéaires sans second membre (f(n) = cte)

A une telle équation, on peut associer un polynôme:

La résolution de ce polynôme nous donne m racines ri ( avec
m<=k).

La solution de l’équation de récurrence est ainsi donnée par :

Cette solution est en général exponentielle
58

59. COMPLEXITÉ DES ALGORITHMES « DIVISER POUR RÉGNER »
AUTRES RÉSOLUTIONS DE RÉCURRENCE

Exemple : La suite de Fibonacci
59

60. SOURCES DE CE COURS

Frédéric Vivien, Algorithmique avancée, École Normale Supérieure de Lyon, 2002.,
pp. 93. Disponible sur http://perso.ens-lyon.fr/frederic.vivien/Enseignement/Algo2001-2002/Cours.pdf

Slim Msfar,
Algorithmique
et Complexité, 2012,
pp
104.
Disponible sur
http://p835.phpnet.org/testremorque/upload/catalogue/coursalgorithmi.pdf

Walid-Khaled Hidouci, La récursivité, École nationale Supérieure d’Informatique,
pp 107. Disponible sur hidouci.esi.dz/algo/cours_recursivite.pdf

La récursivité, Cours d’ Algorithmique et Structures de données dynamiques, École
nationale Supérieure d’Informatique, Année Universitaire 2009-2010.
60