02 - Complexité Des Algorithmes Récursifs

Complexité des algorithmes récursifs.
2ADS Advanced Algorithms
©
© SUPINFO
SUPINFO International
International University
University –– http://www.supinfo.com
http://www.supinfo.com
Objectifs de ce module
• Étudier le cas de la complexité des algorithmes
récursifs :
– En utilisant des suites récurrentes.
– En se servant du “Master Theorem“, sorte de boîte

noire résolvant certaines équations de récurrences.
©
© SUPINFO
Plan de ce module
1. Récursivités “simples“.
2. Algorithmes de type “diviser pour régner“.
©
© SUPINFO
1. Récursivités “simples“
©
© SUPINFO
Plan de ce chapitre
a. Position du problème.
b. Suites arithmétiques et géométriques.
c. Suites récurrentes linéaires.
©
© SUPINFO
• Dans le module précédent on a étudié comment calculer la
complexité d’algorithmes itératifs.
• Ces techniques ne s’appliquent pas à des algorithmes

récursifs.
• Pour ces derniers, la complexité d’un algorithme traitant

des données de taille n va naturellement dépendre de la
complexité du même algorithme avec des données de
taille inférieure.
©
© SUPINFO
• La complexité d’un algorithme récursif va donc être une
suite définie par récurrence.
• Il s’agit de suites dont le n-ième terme est une fonction des

termes précédents :
un = f ( un- 1, un- 2 ,..., un- k )
• On se limitera dans ce cours aux suites arithmético-

géométriques et aux suites récurrentes linéaires d’ordre 2.
©
© SUPINFO
b. Suites arithmétiques / géométriques

Définition :
•Une suite réelle (un)n est arithmético-géométrique s’il existe

deux réels a et b tels que
*
" n Î IN , un =aun- 1 + b
©
© SUPINFO

Définition (suite) :
•Si a = 1 on dit que la suite (un)n est une suite arithmétique

de raison b.
•Si b = 0 on dit que la suite (un)n est une suite géométrique

de raison a.
©
© SUPINFO

Valeur exacte du terme général d’une suite arithmético-
géométrique
Si a =1 " n Î IN, un =u0 + n. b

b
Si a ¹ 1 Soit l = , " n Î IN, un =( u0 - l ) . a n +l
1- a
©
© SUPINFO

Approximation du terme général d’une suite arithmético-
géométrique
Si a =1 un =Q ( n)
Si a >1 un =Q ( a n )
©
© SUPINFO

Exemple 1 : calcul de n! = 1 x 2 x 3 x … x n en utilsant la
relation de récurrence n! = n x (n-1)!.
def factorielle(n):
if n == 0:
return 1
else:
return n*factorielle(n-1)
©
© SUPINFO

Exemple 1 (suite) :
•On a ici T(0) = 1 et T(n) = T(n-1) + 2.
•D’après le résultat précédent, T(n) = 1 + 2n.
•On a donc clairement T ( n ) =Q ( n)
©
© SUPINFO

Exemple 1 (fin) : comparaison avec l’algorithme itératif
def factorielleIteratif(n):
resultat = 1
for i in range(2,n+1):
resultat *= i
return resultat
•Ici aussi on a donc clairement T ( n) =Q ( n)
©
© SUPINFO

Exemple 2 : problème des tours de Hanoï.
•Le but est de déplacer n disques de diamètres différents,

d’une tour initiale à une tour finale en passant par une tour
intermédiaire.
•Initialement, tous les disques sont empilés sur la tour
initiale, du plus grand au plus petit.
©
© SUPINFO

Exemple 2 (suite) :
•Les règles de déplacement sont les suivantes :
– On ne peut bouger qu’un seul disque à la fois.

– On ne peut déplacer un disque que vers une tour vide, ou
sur un disque plus grand.
©
© SUPINFO

Exemple 2 (suite) : étude du cas n = 3
©
© SUPINFO

Exemple 2 (suite) :
•La résolution du problème pour toute valeur de n est donc

récursive :
– On déplace n-1 disques de la tour 1 à la tour 2 en passant

par la tour 3.
– On déplace le plus grand disque de la tour 1 vers la tour 3.
– On déplace n-1 disques de la tour 2 à la tour 3 en passant
par la tour 1.
©
© SUPINFO

Exemple 2 (suite) : l’algorithme résolvant ce problème
def hanoi(de,vers,via,n):
if n==1:
print(de," vers ",vers)
else:
hanoi(de,via,vers,n-1)
print(de," vers ",vers)
hanoi(via,vers,de,n-1)
hanoi("1","3","2",3)
©
© SUPINFO

Exemple 2 (fin) :
•On a ici T(1) = 1 et T(n) = 2T(n-1) + 2.
•D’après le résultat précédent sur les suites arithmético-

géométriques, on a :
T ( n) =Q ( 2 n )
©
© SUPINFO

Définition :
•Une suite réelle (un)n vérifie une relation de récurrence

linéaire homogène d’ordre 2 s’il existe deux réels a et b tels
que
" n ³ 2, un =aun- 1 + bun- 2
©
© SUPINFO

Équation caractéristique :
•Il s’agit de l’équation polynomiale de degré 2
( E) x 2 - ax - b =0
•On va exprimer le terme général d’une suite récurrente

linéaire d’ordre 2 en fonctions des racines de cette équation.
©
© SUPINFO

Théorème : soit Δ le discriminant de l’équation (E).
•Si Δ > 0 : soient x1 et x2 les deux racines réelles distinctes de

(E).
$ l , m Î IR, " n Î IN, un =l. x + m. x
n
1
n
2
•Si Δ = 0 : soit x la racine réelle double de (E).
$ l , m Î IR, " n Î IN, un =( l. n + m ) . x n
©
© SUPINFO

Remarque :
•Les constantes λ et μ se déterminent à l’aide de la valeur des

deux termes u0 et u1 (ou u1 et u2).
•On a alors un système linéaire de deux équations à deux

inconnues à résoudre.
©
© SUPINFO

Exemple : la suite de Fibonnaci est définie par
ì 0 si n =0
ï
un =í 1 si n =1
ï u +u si n ³ 2
î n- 1 n- 2
Ses premiers termes sont donc :
0,1,1, 2, 3, 5,8,13, 21,...
©
© SUPINFO

Exemple (suite) :
•L’équation caractéristique est donc
( E) x 2 - x - 1 =0
•On a alors
1+ 5 1- 5
D =5, x1 = et x2 =
2 2
©
© SUPINFO

Exemple (suite) :
•D’après le résultat du théorème
n n
æ1+ 5 ö æ1- 5 ö
$ l , m Î IR, " n Î IN, un =l. ç ÷ + m. ç ÷
è 2 ø è 2 ø
©
© SUPINFO

Exemple (suite) :
•On a u0 = 0 et u1 = 1 donc
ì0 =l + m
ï
í æ1+ 5 ö æ1- 5 ö
ï1 =l. ç ÷+ m. ç ÷
î è 2 ø è 2 ø
©
© SUPINFO

Exemple (fin) :
•En résolvant le système précédent par substitution on

montre que
1 1
l = et m =-
5 5
•Et donc
n n
1 æ1+ 5 ö 1 æ1- 5 ö
" n Î IN, un = . ç ÷- .ç ÷
5 è 2 ø 5 è 2 ø
©
© SUPINFO

Rappels sur les limites :
si x >1 x n ® +¥
si - 1 < x <1 xn ® 0
n
si x £- 1 x n'a pas de limite
©
© SUPINFO

Approximation du terme général
•Si Δ > 0, si x1 > 1 et si abs(x1) > abs(x2) alors
un =Q ( x1n )
•Ce résultat signifie moralement que, sous ces conditions, x1n

impose le comportement asymptotique de la suite.
©
© SUPINFO

Exemple :
•Pour la suite de Fibonnaci, on a montré que
1+ 5 1- 5
D =5, x1 = et x2 =
2 2
•Donc on a bien Δ > 0, x1 > 1 et abs(x1) > abs(x2). Ainsi
ææ ö
nö
ç 1+ 5 ÷
un =Q ç ÷
çè 2 ø ÷
è ø
©
© SUPINFO

Suites non homogènes
•Une suite réelle (vn)n vérifie une relation de récurrence

linéaire non homogène d’ordre 2 s’il existe deux réels a et b
et une fonction f tels que

( )
" n ³ 2, v n =av n- 1 +bv n- 2 + f n
©
© SUPINFO

Étude d’une suite non homogène
•On étudie d’abord la suite homogène associée
" n ³ 2, un =aun- 1 + bun- 2
•Si pour cette suite (un)n , Δ > 0, x1 > 1 et abs(x1) > abs(x2) et si
de plus f(n) est une fonction polynomiale alors
vn =Q ( x1n )
©
© SUPINFO

Exemple : l’algorithme calculant le n-ième terme de la suite
de Fibonnaci.
def fibonnaci(n):
if n<2:
return n
else:
return fibonnaci(n-1) + fibonnaci(n-2)
©
© SUPINFO

Exemple (suite) :
•On a ici T(0) = T(1) = 1 et T(n) = T(n-1) + T(n-2) + 2. Il s’agit

d’une suite non homogène.
•On est donc ramené à l’étude de la suite homogène :
ì 0 si n =0
ï
un =í 1 si n =1
ï u +u si n ³ 2
î n- 1 n- 2
©
© SUPINFO

Exemple (fin) :
•On est dans le cadre du résultat précédent sur les suites non
homogènes donc
ææ ö
nö
1+ 5
T ( n ) =Q çç ÷÷
çè 2 ø ÷
è ø
©
© SUPINFO
Fin de ce chapitre
Avez – vous des questions ?
©
© SUPINFO
2. Algorithmes de type “diviser

pour régner“.
©
© SUPINFO
Plan de ce chapitre
b. L’exemple du tri fusion.
c. Le “master theorem“ (cas simple).
d. Le “master theorem“ (cas général).
©
© SUPINFO
Rappel des trois étapes du paradigme “diviser pour régner“
①Diviser : on divise les données initiales en plusieurs sous-

parties.
②Régner : on résout récursivement chacun des sous-

problèmes associés (ou on les résout directement si leur
taille est assez petite).
③Combiner : on combine les différents résultats obtenus

pour obtenir une solution au problème initial.
©
© SUPINFO
• Avec ce paradigme, la complexité d’un algorithme traitant
des données de taille n va naturellement dépendre de la
complexité du même algorithme avec des données de
taille n/b, où b est le facteur avec lequel on divise le
problème en sous-problèmes.
• Il faudra tenir compte aussi de la complexité de l’étape de

combinaison des résultats des sous-problèmes.
• On va commencer par un exemple : le tri fusion.
©
© SUPINFO

Rappel du principe
•À chaque appel récursif :

– On scinde la liste à trier en deux sous-listes de même taille
(à un élément près).
– On trie chacune de ces deux sous-listes.
– On fusionne les deux sous-listes triées en une seule.
•La condition d’arrêt à la récursivité est l’obtention de listes

d’une seule valeur, et donc déjà triées.
©
© SUPINFO

Exemple de fonctionnement
•On considère la liste suivante de 7 entiers :
7 5 14 4 10 2 8
©
© SUPINFO

•On la scinde en deux sous-listes :
7 5 14 4 10 2 8
7 5 14 4 10 2 8
©
© SUPINFO

•Sous-listes que l’on scinde à leur tour :
7 5 14 4 10 2 8
7 5 14 4 10 2 8
©
© SUPINFO

•Sous-listes que l’on scinde à leur tour :
7 5 14 4 10 2 8
7 5 14 4 10 2 8
©
© SUPINFO

•Ces sous-listes sont triées (elles n’ont qu’un élément), on va
maintenant les fusionner :
7 5 14 4 10 2 8
5 7 4 14 2 10 8
©
© SUPINFO

•De nouveau une étape de fusionnnement :
5 7 4 14 2 10 8
4 5 7 14 2 8 10
©
© SUPINFO

•Encore une fusion :
4 5 7 14 2 8 10
2 4 5 7 8 10 14
©
© SUPINFO

Exemple de fonctionnement : fin
•On a fusionné toutes les sous-listes obtenues lors des appels

récursifs, le tri est terminé.
2 4 5 7 8 10 14
©
© SUPINFO

Algorithme du tri fusion :
def fusion(l,first,middle,last):
i,j = first,middle+1
pro = []
while (i<=middle) and (j<=last):
if l[i]<=l[j]:
pro.append(l[i])
i+=1
else:
pro.append(l[j])
j+=1
while i<=middle:
pro.append(l[i])
i+=1
while j<=last:
pro.append(l[j])
j+=1
for k in range(last-first+1):
l[first+k] = pro[k]
©
© SUPINFO

Algorithme du tri fusion (suite) :
def triFusionRec(l,first,last):
if first<last:
triFusionRec(l,first,(first+last)//2)
triFusionRec(l,((first+last)//2)+1,last)
fusion(l,first,(first+last)//2,last)
def triFusion(l):
triFusionRec(l,0,len(l)-1)
©
© SUPINFO

Complexité du tri fusion :
•La complexité du tri fusion est
T ( n ) =O ( n ´ log 2 ( n ) )
•On peut d’ailleurs démontrer que c’est la meilleure

complexité que l’on puisse avoir sur un algorithme de tri.
©
© SUPINFO

Éléments de preuve :
•La complexité de la procédure de fusion est linéaire.
•Plus précisément, pour fusionner deux tableaux de taille

n/2, on a une complexité en O(n).
•Dans l’algorithme précédent n étant la différence entre

“last” et “first” et donc n/2 la différence entre “middle” et
“first” ou “last” et “middle”.
©
© SUPINFO

Éléments de preuve (suite) :
•Dans la suite de cette preuve on va supposer que n est une

puissance de 2.
•À chaque appel récursif, on subdivise un problème de taille

n en 2 sous-problèmes de taille n/2.
©
© SUPINFO

•À un niveau j on a donc 2j sous-problèmes.
•Chacun de ces sous-problèmes est de taille n/2j et aura donc

un coût de l’ordre de n/2j.
æn ö
•Le coût d’un niveau j est donc j
2 ´ ç j ÷=n
è2 ø
©
© SUPINFO

Coût de chaque
Éléments de preuve (suite) : niveau
æn ö
2 ´ ç ÷=n
è2 ø
æn ö
2 2 ´ ç 2 ÷=n
è2 ø
æn ö
2 3 ´ ç 3 ÷=n
è2 ø
log 2 ( n) æ n ö
2 ´ ç log ( n) ÷=n
è2 2 ø
©
© SUPINFO

Éléments de preuve (fin) :
•La hauteur h de l’arbre vaut log2(n) car elle vérifie 2h = n.
•On a donc log2(n) + 1 niveaux.
•Chaque niveau est de coût n.
•Conclusion : T ( n ) =O ( n ´ log 2 ( n ) )
©
© SUPINFO
c. Le “master theorem” (cas simple).

Contexte : étude des algorithmes “diviser pour régner” de la
forme
def divideAndConquer(n):
if n ==1:
end of processing
else:
divideAndConquer(n//b)
... a times
work of cost f(n) for dividing the problem
and merging the solutions to
the subproblems
©
© SUPINFO

Master Theorem : soit T une fonction vérifiant
æn ö
T ( n) =aT ç ÷+ f ( n )
èb ø
•Où a ≥ 1 et b > 1. Signification des paramètres :

– n est la taille du problème.
– a est le nombre de sous-problèmes.
– n/b est la taille de chaque sous-problème.
– f(n) est le “coût“ de la subdivision et de la combinaison des
solutions des sous-problèmes.
©
© SUPINFO

Master Theorem (suite) :
•On suppose que : f ( n ) =Q ( n d )
•Alors :
ì d
ï Q ( )
n si log b ( a) < d
ï
T ( n ) =í Q ( n d log ( n ) ) si log b ( a) =d
ï
ï Q n logb ( a)
( ) si log b ( a) > d
î
©
© SUPINFO

Master Theorem (suite) : formulation équivalente.
•On suppose que : f ( n ) =Q ( n d )
•Alors :
ì d
ï Q ( )
n si a < b d
ï
T ( n) =í Q ( n d log ( n ) ) si a =b d
ï
ï Q n logb ( a)
( ) si a > b d
î
©
© SUPINFO

Éléments de preuve :
•Dans la suite de cette preuve on va supposer que n est une

puissance de b.
•À chaque appel récursif, on subdivise un problème de taille

n en a sous-problèmes de taille n/b.
©
© SUPINFO

•À un niveau j on a donc aj sous-problèmes.
•Chacun de ces sous-problèmes est de taille n/bj et aura donc

un coût de l’ordre de (n/bj)d.
d
•Le coût d’un niveau j est donc j æn ö
a ´ ç j÷
èb ø
©
© SUPINFO

Coût de chaque
Éléments de preuve (suite) : niveau
a appels récursifs nd
d
æn ö
a´ ç ÷
èb ø
d
2æn ö
a ´ ç 2÷
èb ø
d
3æn ö
a ´ ç 3÷
èb ø
d
logb ( n) æ n ö
a ´ ç log ( n) ÷
èb b ø
©
© SUPINFO

•Pour évaluer T(n) on doit alors calculer la somme
logb ( n) d logb ( n) j
æn ö æa ö
å a ´ ç j ÷ =n d
j
èb ø
å ç d÷
èb ø
j=0 j=0
a
•Tout dépend donc de la valeur
bd
©
© SUPINFO

Interprétation :
j
d æa ö
•Le coût d’un niveau j est donc proportionnel à n ç d÷
èb ø
•a : taux de division en sous-problèmes.
•bd : taux de diminition du coût de traitement par sous-

problème.
©
© SUPINFO

Interprétation (suite) :
•Si a < bd, le coût d’un niveau est une fonction décroissante
de j. Moralement la complexité sera essentiellement celle de
l’appel initial donc en nd.
•Si a = bd, le coût d’un niveau est une fonction constante de j

et vaut nd. La complexité sera alors égale à nd multiplié par le
nombre de niveau qui est logb(n).
©
© SUPINFO

Interprétation (fin) :
•Si a > bd, le coût d’un niveau est une fonction croissante de j.
Moralement la complexité sera essentiellement celle due aux
appels finaux. Elle sera donc de l’ordre du nombre de feuilles
de l’arbre des appels récursifs, i.e. nlogb(a).
©
© SUPINFO

Éléments de preuve (suite) : cas a = bd.
log b ( n) j log b ( n)
æa ö
nd å ç d÷ =
èb ø
nd å 1
j=0 j=0
= n d ´ log b ( n )
D’où d
T ( n ) =Q ( n log ( n ) )
©
© SUPINFO

Rappel sur les suites géométriques :
r 1 r 1
r
1  q q 1
si q  1, q j

j 0 1 q q 1
r
1
si q  1, q  j
j 0 1 q
r 1
r 1 
r
q
si q  1, q j
 q 1  
j 0 q 1  q 1
©
© SUPINFO

Éléments de preuve (suite) : cas a < bd.
log b ( n) j
æa ö 1
n d
å ç d ÷ £n
èb ø
d
a
j=0 1- d
b
D’où T ( n ) =Q ( n d )
©
© SUPINFO

Éléments de preuve (suite) : cas a > bd.
j
æ ö
logb ( n )
æa ö dæa ö
logb ( n )
ç 1 ÷
n å ç d ÷ £n ç d ÷ ç1+
d
÷
èb ø èb ø ç a
j=0 - 1 ÷
è bd ø
Or
nd - d log b ( n) logb ( n)
-d
b
d log b ( n)
=n b d d
=n b ( ) =n d n - d =1
©
© SUPINFO

Éléments de preuve (fin) : cas a > bd.
log b ( n)
•On a alors (
T ( n) =Q a )
•On conclut alors en constatant que ( ) =n log b ( a)

log b n
a
puisque les logarithmes de ces deux quantités dans la

base b sont égaux.
©
© SUPINFO

Exemple :
•Pour le tri fusion on a a = 2, b = 2 et d = 1.
•On retrouve bien sûr le résultat démontré sur ce cas

particulier au début de cette partie.
©
© SUPINFO
d. Le “master theorem” (cas général).

Master Theorem : soit T une fonction vérifiant
æn ö
T ( n) =aT ç ÷+ f ( n )
èb ø
•Où a ≥ 1 et b > 1. Signification des paramètres :

– n est la taille du problème.
– a est le nombre de sous-problèmes.
– n/b est la taille de chaque sous-problème.
– f(n) est le “coût“ de la subdivision et de la combinaison des
solutions des sous-problèmes.
©
© SUPINFO

Master Theorem (suite) :
( ) ( ) ( )
d
si f n =O n avec d < log b a alors T n =Q n ( ) ( log b a ( )
)
si f ( n ) =Q ( n ) avec d =log ( a ) alors T ( n ) =Q ( n ( ))
d ( )
log b a
b
log n
ænö
( ) ( ) d
si f n =W n avec d > log b a et si a. f ç ÷£c. f n avec c <1
èbø
( ) ( )

( )
alors T n =Q f n( ( ))
©
© SUPINFO

Remarque : voici des exemples où le “master theorem” ne
s’applique pas
n æn ö 3
T ( n ) =2 T ç ÷+ n
è2 ø
æn ö æn ö 2
T ( n ) =T ç ÷+T ç ÷+ n
è2 ø è 4 ø
1 æn ö
T ( n ) = T ç ÷+ n
2 è2 ø
©
© SUPINFO

Remarque (suite) :
•Pour ces cas là on pourra par exemple considérer l’arbre des

appels récursifs et l’analyser “finement”.
©
© SUPINFO
Fin de ce chapitre
Avez – vous des questions ?
©
© SUPINFO
Structures de données linéaires.
©
© SUPINFO

02 - Complexité Des Algorithmes Récursifs

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

02 - Complexité Des Algorithmes Récursifs

Transféré par

Droits d'auteur :

Formats disponibles

Complexité des algorithmes récursifs.

2ADS Advanced Algorithms

– En utilisant des suites récurrentes.

– En se servant du “Master Theorem“, sorte de boîte

• Ces techniques ne s’appliquent pas à des algorithmes

• Pour ces derniers, la complexité d’un algorithme traitant

• Il s’agit de suites dont le n-ième terme est une fonction des

un = f ( un- 1, un- 2 ,..., un- k )

• On se limitera dans ce cours aux suites arithmético-

b. Suites arithmétiques / géométriques

•Une suite réelle (un)n est arithmético-géométrique s’il existe

b. Suites arithmétiques / géométriques

•Si a = 1 on dit que la suite (un)n est une suite arithmétique

•Si b = 0 on dit que la suite (un)n est une suite géométrique

b. Suites arithmétiques / géométriques

Si a =1 " n Î IN, un =u0 + n. b

b. Suites arithmétiques / géométriques

b. Suites arithmétiques / géométriques

b. Suites arithmétiques / géométriques

•On a ici T(0) = 1 et T(n) = T(n-1) + 2.

•D’après le résultat précédent, T(n) = 1 + 2n.

•On a donc clairement T ( n ) =Q ( n)

b. Suites arithmétiques / géométriques

•Ici aussi on a donc clairement T ( n) =Q ( n)

b. Suites arithmétiques / géométriques

•Le but est de déplacer n disques de diamètres différents,

b. Suites arithmétiques / géométriques

•Les règles de déplacement sont les suivantes :

– On ne peut bouger qu’un seul disque à la fois.

b. Suites arithmétiques / géométriques

b. Suites arithmétiques / géométriques

•La résolution du problème pour toute valeur de n est donc

– On déplace n-1 disques de la tour 1 à la tour 2 en passant

b. Suites arithmétiques / géométriques

b. Suites arithmétiques / géométriques

•On a ici T(1) = 1 et T(n) = 2T(n-1) + 2.

•D’après le résultat précédent sur les suites arithmético-

c. Suites récurrentes linéaires.

•Une suite réelle (un)n vérifie une relation de récurrence

" n ³ 2, un =aun- 1 + bun- 2

c. Suites récurrentes linéaires.

•Il s’agit de l’équation polynomiale de degré 2

•On va exprimer le terme général d’une suite récurrente

c. Suites récurrentes linéaires.

•Si Δ > 0 : soient x1 et x2 les deux racines réelles distinctes de

•Si Δ = 0 : soit x la racine réelle double de (E).

$ l , m Î IR, " n Î IN, un =( l. n + m ) . x n

c. Suites récurrentes linéaires.

•Les constantes λ et μ se déterminent à l’aide de la valeur des

•On a alors un système linéaire de deux équations à deux

c. Suites récurrentes linéaires.

Ses premiers termes sont donc :

0,1,1, 2, 3, 5,8,13, 21,...

c. Suites récurrentes linéaires.

•L’équation caractéristique est donc

c. Suites récurrentes linéaires.

•D’après le résultat du théorème

c. Suites récurrentes linéaires.

c. Suites récurrentes linéaires.

•En résolvant le système précédent par substitution on

c. Suites récurrentes linéaires.

c. Suites récurrentes linéaires.

•Si Δ > 0, si x1 > 1 et si abs(x1) > abs(x2) alors