Najlàa ESSALHI 2021-2022 CPGE Mohamed V-Casablanca

Chapitre 1 : initiation à la complexité algorithmique

I. Introduction
Plusieurs algorithmes peuvent être proposés pour résoudre un même problème. Ainsi, choisir un parmi eux est nécessaire.
Il existe plusieurs critères pour faire un choix optimal, les plus pertinents sont le temps d’exécution et l’espace mémoire
demandé par l’algorithme puisque ces deux critères affectent directement deux ressources partagées sur l’ordinateur. Il est
donc indispensable d’estimer le temps de calcul d’un algorithme et l’espace mémoire utilisé, afin de juger sa qualité.
La complexité d'un algorithme est une mesure de la quantité de ressources nécessaires à son exécution. On distingue deux
types de complexité :
• Complexité temporelle : mesure le temps de calcul consommé lors de l’exécution d’un programme.
• Complexité spatiale : mesure le nombre d’emplacement mémoire occupé lors de l'exécution d'un programme.
Remarque :
• On s’intéressera plus, dans ce cours, à la complexité temporelle.
Complexité temporelle :
On ne mesure pas le temps d’exécution des algorithmes d’une façon expérimentale car ces mesures sont liées à la machine
et cela demande de les implémenter. On estime donc ce temps d’exécution d’une façon théorique en utilisant des unités de
temps abstraites correspondant au nombre d’opérations effectuées.
Paramètre de complexité :
La complexité d’un programme peut augmenter quand la taille des données d’entrée devient importante et vice-versa. Nous
estimerons par conséquent la complexité d’un algorithme comme fonction de la taille (ou valeurs) des données d’entrée qu’on
appel un paramètre de complexité.
Exemple :
• Le paramètre de complexité de la fonction factoriel (n) est : la valeur de n.
• Pour une fonction de recherche séquentielle d'un élément dans une liste c’est : la longueur de la liste.

II. Calcul du coût d’un algorithme :

1. Cout des instructions élémentaires :
On appelle opération de base, ou opération élémentaire, toute :
ü Affectation
ü Test de comparaison : = =, <, ≤, ≥, !=
ü Opération de lecture et écriture
ü Opération arithmétique : +, -,*, /, %

On considère que toutes ces opérations élémentaires ont le même coût qui égale à 1, indépendamment des données d’entrée.
Ainsi, si on considère deux blocs d’instructions P et Q avec CP est le cout du bloc P et CQ est le cout du bloc Q, alors le cout
total est CP + CQ
Exemple :
Algorithme Complexité
S=1 # instruction 1
S=S*n # instruction 2 CA = C instruction 1 + C instruction 2 + C instruction 3 = 1 + 2 + 2 = 5
S=S-n # instruction 3
Najlàa ESSALHI 2021-2022 CPGE Mohamed V-Casablanca

2. Cout d’une instruction conditionnelle :

si test alors :
Q1
sinon :
Q2
Finsi

Si le cout de Q1 est CQ1 et celui de Q2 est CQ2, alors on a: C ≤ C test + max (CQ1, CQ2)

Exemple :

Algorithme Complexité
if i % 2= = 0 : #test
n = i // 2 #bloc 1
else : CB ≤ C test + max (C bloc 1, C bloc 2) ≤ 2 + max (2,4) ≤ 6
i = i+1 #bloc 2
n = i // 2

3. Coût d’une boucle :

Si P est une instruction de la forme : Si P est une instruction de la forme :

pour i de 1 à p faire while test :

Q Q
Finpour
Alors le cout de P est : CP = ( 𝐶)*+) + 𝐶" )
$
Alors le cout de P s’exprime : CP = %&' 𝐶"

Exemple 1 :

Algorithme Complexité
S=0
3 3
for i in range(n+1) :
S=S+i 𝐶(𝑛) = 1 + 𝐶1&12% = 1 + 2 = 1 + 2 𝑛 + 1 = 2𝑛 + 3
%&4 %&4

Exemple 2 :

Algorithme Complexité
for i in range(n):
for j in range(i): >@' :@' >@' :@' >@'
n(n − 1)
S=i+j C(n) = C 9&:2; + C<=:>? 9 = 3= 3i = 3
2
print(S) :&4 ;&4 :&4 ;&4 :&4

Exemple 3 :

Algorithme Complexité

i=0 Le corps de la boucle « while » va être exécutée n+1 fois et le test de la

s=0 boucle va être exécuté n+2 fois :
while i <= n :
Najlàa ESSALHI 2021-2022 CPGE Mohamed V-Casablanca

s=s+i 32' 3 32' 3

i=i+1 𝐶 𝑛 =2 + 𝐶%C3 + 𝐶+&+2% + 𝐶%&%2' = 2 + 1+ 4

%&4 %&4 %&4 %&4
= 2 + 𝑛 + 2 + 4 𝑛 + 1 = 8 + 5𝑛

4. Appel d’une fonction

Lorsqu'une fonction ou une procédure est appelée, le cout de cette fonction ou procédure est le nombre total d'opérations
élémentaires engendrées par l'appel de cette fonction.
III. Type de complexité :
Pour des données d’entrée de même taille, un algorithme n'effectue pas nécessairement le même nombre d'opérations
élémentaires. C’est pour ça on distingue 3 types de complexité :

Meilleur des cas Pire des cas complexité en moyenne

C’est un minorant du C’est un majorant du temps C’est une moyenne de la complexité, pondérée entre les
temps d’exécution pour d’exécution possible pour différentes entrées possibles :
toutes les entrées possibles toutes les entrées possibles Moy = p d CL
d’une même taille d’une même taille. <MN= ?MN?O O>?=éO L

p(d) probabilité d’apparition de l’entrée d et Cd son temps

d’exécution

Remarque :
Généralement, on s’intéresse à la complexité dans le pire des cas, car cela correspond à la performance de l’algorithme
lorsqu’il prend le plus de temps.
Exemple : recherche d’un élément X dans un tableau
def recherche(X,T) :
for i in range(len(T)) :
if X==T[i] :
return True
return False

La complexité est évaluée en comptant le nombre de comparaisons effectuées :

Meilleur des cas Pire des cas complexité en moyenne

• Soit p la probabilité que X est dans le tableau T, alors :

lorsque X est égal lorsque X n’est pas o La probabilité que X se trouve dans la ième case est
V
puisqu’il peut se
3
au premier dans T ou bien il est le
trouver dans n'importe quelle case avec la même probabilité
élément de T. On dernier.
o La probabilité que X ne soit pas dans le tableau T est (1 - q)
effectue donc une On effectue n=len(T)
• Le cout dépend de nombre de comparaisons effectuées :
comparaison et un comparaisons et un
o Si X est dans la ième case de T alors on effectuera « i » comparaisons
return return
o Si X n’est pas dans T alors on effectuera « n » comparaisons
𝐧@𝟏

𝐂 𝐧 = 𝟏+𝟏 • Donc :
C(n) = 2 𝐢&𝟎
 Najlàa ESSALHI 2021-2022 CPGE Mohamed V-Casablanca

𝐧
=𝐧+ 𝟏 𝐪 𝐪𝐧 𝐧+𝟏 𝐧+𝟏
𝐂 𝐧 = 𝐢 + 𝐧 𝟏−𝐪 = +𝐧 𝟏−𝐪 =𝐪 +𝐧 𝟏−𝐪
𝐧 𝐧 𝟐 𝟐
𝐢&𝟏

• Si on est sur que X appartient au tableau T (q=1) alors :

𝐧+𝟏
𝐂 𝐧 =
𝟐

IV. Complexité asymptotique et notation O :

Il est souvent inutile d’évaluer de façon exacte le nombre d’opérations effectuées par un algorithme, on fait recours donc à une
approximation de ce nombre d’opérations représentant ce qu’on appel ordre de grandeur de la complexité.
1. Notation O :
On dit que une fonction f est dominée par une fonction g si et seulement si :
∃(n0, c) > 0 telle que f(n) ≤ c * g (n) ∀n ≥ n0
On notera: f = O(g) et on dit que f est du même ordre de grandeur que g

Remarque :
• Si f=O(g) et g=O(h) alors f=O(h)
• Si f=O(g) et k une constante alors k*f=O(g)
• Si f1=O (g1) et f2=O (g2) alors : f1+f2= O (g1+g2) et f1*f2= O (g1*g2)
Règles de simplification :
• Un nombre constant d’instructions est négligeable par rapport à la croissance de la taille des données, ce qui permet
d’annuler les constantes additives.
• Pour de grandes valeurs de n, c’est bien sûr le terme de plus haut degré qui est dominant
• Les processeurs actuels effectuent plusieurs millions d’opérations par seconde, on remplace donc les constantes
multiplicatives par des 1
Exemples :
• f (n) = n3 + 2n2 + 4n + 2 = O(n3) (si n ≥1 alors f (n) ≤ 8n3)
• f (n) = n log(n) + 12n + 888 = O(n log(n))
[\
• f (n) = 1000n10 − n7 + 12n4 + = O(2n)
'444

Remarque : La complexité d’une instruction élémentaire est un O(1) : on dit qu’elle s’effectue en temps constant
2. Classes de complexité les plus usuelles :
Les algorithmes se regroupent en plusieurs familles, selon leurs complexités :

temps constant O(1) quelque soit la taille de l’entrée, le nombre d’opérations effectuées est constant.

temps sous linéaire O(log(n)) Le temps présente une dépendance logarithmique par rapport à la taille de l’entrée.

temps linéaire O(n) si la taille de l’entrée double, le temps double

temps quasi-linéaire O(nlog(n)) augmentation un peu supérieur à O(n)

temps quadratique O(n2) quand la taille de l’entrée double, le temps d'exécution est multiplié par 4
 Najlàa ESSALHI 2021-2022 CPGE Mohamed V-Casablanca

temps polynomial O(nk) quand la taille de l’entrée double, le temps d'exécution est multiplié par 2k

temps exponentiel O(kn) quand la taille de l’entrée double, le temps d'exécution est élevé à la puissance 2

factorielle O (n!) asymptotiquement équivalente à nn

1. Exemples :
ü Exemple 1 : La fonction factorielle

• En fixant le « i » on exécute 2 opérations élémentaires (multiplication et affectation) ce

def factorielle (n):
qui donne une complexité en O(1)
resultat = 1
• La boucle for va exécuter n-1 fois (de i=2 jusqu’à n) un traitement de temps constant,
for i in range(2 , n+1):
donc elle a une complexité : (n-1)*O(1) = O(n-1) = O(n)
resultat = resultat* i
• A l’extérieur de la boucle nous avons deux opérations élémentaires : return et affectation
return resultat
qui s’exécutent en temps constant O(1)
• La complexité est donc : O(n) + O(1) = O(n)

ü Exemple 2 : recherche dichotomique : recherche de l’élément x dans une liste L triée

• Le paramètre de complexité est : n=len(L)

def rechercheDicho(L, x): • Chaque tour de boucle se fait avec une complexité constante, il reste à estimer le nombre
d =0 de tours de boucle effectués.
f=len(L)-1 • Notons di et fi les valeurs des variables d et f après i tour de boucle et t : = f: − d: + 1.
while d<= f: Initialement, f4 = n − 1 et d4 = 0, donc t 4 = n
m = (d+f)//2 • Distinguons les cas :
if L[m] == x: ü si « f » prend la valeur m-1 après un tour de boucle :
return True Lg 2hg Lg 2hg @'
On a: f:2' = −1 ≤ et d:2' = d:
[ [
elif L[m] > x: d : + f: − 1 f: − d : + 1 t:
donc: t :2' = f:2' − d:2' + 1 ≤ − d: + 1 = =
f= m – 1 2 2 2

else: ü si « d » prend la valeur m+1 après un tour de boucle supplémentaire :

d : + f: d : + f: + 1
d= m + 1 On a: d:2' = +1 ≥ et f:2' = f:
2 2
return False d : + f: + 1 f: − d : + 1 t:
donc: t :2' = f:2' − d:2' + 1 ≤ f: − +1= =
2 2 2
?lmn ?o 3
• Ainsi, on vérifie aisément par récurrence que : t k ≤ ≤ =
[ [l [p

• La dernière itération de la boucle divise une instance de taille 1 c'est-à-dire:

3 3
t k < 1, alors on a : < 1 𝑒𝑡 𝑡t@' = 1 ≤ on conclut que le nombre d’itérations
[p [pmn

log [ 𝑛 < 𝑘 ≤ log [ 𝑛 + 1

• La complexité au pire des cas est donc : O (log2(n))
ü Exemple 3 : vérifier si un tableau contient des doublons

Soit n=len(T) la longueur du tableau en entrée.

def sansDoublons (T) :
Najlàa ESSALHI 2021-2022 CPGE Mohamed V-Casablanca

n= len(T) • Dans le pire des cas le programme ne va pas trouver de doublons et retourne True, donc
for i in range (n-1) : il va comparer tous les éléments du tableau entre eux.
for j in range (i +1, n) : >@[ >@' >@[ >@'
n n−1
if (T [i] = = T [j]) : 3+ 1 =3+ n−1−i =3+ i=3+ = O(n[ )
2
:&4 ;&:2' :&4 :&'
return False
return True • Dans le meilleur des cas les deux premiers éléments de T sont identiques (une seule
comparaison et un return) on aura donc une complexité constante O(1)

ü Exemple 4 : produit matriciel

def ProduitMatriciel (A, B) : • En effectue 3 affectations et 3 appels à la fonction « len » donc: cout= 6
n=len(A)
• Pour initialiser la matrice « prod », en effectue n multiplications et une
m= len(B[0])
p= len(B) affectation ce qui donne un cout= n+1
prod = [[0]*m for i in range(n) ] • Pour calculer une valeur de s : 3 opérations élémentaire (affectation, addition,
for i in range(n) : multiplication)
>@' y@' <@' >@' y@'
for j in range(m) :
s=0 C n =6+n+1+ 2+ 3 +1=8+n+ 2 + 3p
:&4 ;&4 k&4 :&4 ;&4
for k in range(p) :
s= s + A[i][k] * B[k][j] = 8 + n + n. m. 2 + 3p = 8 + n + 2n. m + 3p. n. m
= O(p. n. m)
prod[i][j]=s
• Si les matrice A et B sont des matrices carrées alors n=m=p ce qui donne une
return prod
complexité en O (n3)

V. Complexité des fonctions récursives :

L’étude de la complexité d’un algorithme récursif consiste principalement à déterminer le nombre d’appels récursifs en
fonction de la taille des données d’entrée. En règle générale, la complexité d’un algorithme récursif traitant des données d'une
certaine taille va dépendre de la complexité du même algorithme avec des données de taille inférieure. Cette complexité va
donc être une suite définie par récurrence.
1. Récursivités simples :
a. Suites arithmético-géométriques:
Une suite réelle (Un) n∈ℕ est dite arithmético-géométrique si : ∃ a, b є R tels que ∀ n ∈ N* Un = a Un−1 + b
Dans le contexte de calculs de complexité, a, b et U0 sont positifs, on a alors :
• Si a=1, alors : ∀ n ∈ ℕ Un=U0+n b = O(n)
}
• Si a>1, on pose L= , alors : ∀n∈ℕ Un = (U0−L) an + L = O (an)
'@~

Exemple : fonction factorielle récursive

• Si n>1, en effectue une comparaison lors du test, un produit et un appel récursif

def factorielle(n):
sur une entrée de taille n-1.
if n <= 1:
• Si n≤1, seule la comparaison a lieu.
return 1
• La complexité est donc une suite arithmético-géométrique associée aux
else:
constantes a=1 et b=2 :
return n*factorielle(n-1)
Najlàa ESSALHI 2021-2022 CPGE Mohamed V-Casablanca

C(n) = C(n−1) + 2 pour n>1 et C(0) = C(1) = 1

• Cet algorithme est donc de complexité linéaire :
C(n) = C(1) + (n-1) b = 1+2(n-1) = 2n-1 = O(n)

b. Suites récurrentes linéaires

• Suites homogènes
Une suite réelle (Un) n∈ℕ est récurrente linéaire homogène d'ordre deux si :
∃a,b є R tels que ∀ n ≥ 2, Un = a Un-1 + b Un-2
Pour étudier une telle suite, on lui associer un polynôme caractéristique: X2 – a X - b
Soit Δ le discriminant de l’équation caractéristique associée X2 - a X - b = 0 :
ü Si Δ>0, soit X1 et X2 les deux racines avec X1> 1 et |X1| > |X2| alors : ∃ λ,µ∈R, ∀n∈N, Un = λ X1n +µ X2n = O (X1n)
ü Si Δ=0 et X la racine réelle double: ∃λ,µ ∈ R, ∀ n ∈ N, Un = (λn+µ) Xn = O(Xn)
Les constantes λ et µ se déterminent à l’aide des valeurs des deux premiers termes de la suite.
• Suites non homogènes
Une suite réelle (Un) n∈ℕ est récurrente linéaire non homogène d'ordre deux s'il existe deux réels a et b et une
fonction F de ℕ dans ℝ, tels que : ∀ n ≥ 2, Un = a Un-1 + b Un-2 + F (n)
Le principe de résolution consiste à éliminer d’abord la fonction F(n), et ensuite résoudre l’équation homogène ainsi trouvée.

Exemple : calcul du nième terme de la suite de Fibonacci

def Fibonacci(n):
if n<2:
return n
else:
return Fibonacci(n-1) + Fibonacci(n-2)

Complexité :
Si n>2, on effectue une comparaison et une addition entre deux appels récursifs. Si n=0 ou n=1, seule la comparaison a lieu.
On a ainsi :
C(n) = C(n − 1) + C(n − 2) + 2 (1)
C(0) = C(1) = 1
La complexité est donc une suite récurrente linéaire non homogène d'ordre deux. Cette récurrence est aussi vraie pour n+1 :
C n+1 = C n + C n−1 + 2 (2)
En soustrayant (1) de (2), on obtient l’équation suivante :
C(n + 1) − 2C(n) + C(n − 2) = 0
Cette nouvelle équation est une équation homogène dont l'équation caractéristique est :
X• − 2 X[ + 1 = X − 1 X[ − X − 1 = 0
et dont les racines sont :
' 2 ‚ ' @ ‚
X1 = et X2 = et X3=1
[ [
Donc :
> > >
1+ 5 1– 5 1 + 5
∃µ, λ, γ ∈ ℝ, C(n) = λ +µ +γ=O
2 2 2
Najlàa ESSALHI 2021-2022 CPGE Mohamed V-Casablanca

On détermine alors λ, µ et 𝛾 en se servant de la valeur des trois premiers termes C(0) = 1 et C(1) = 1 et C(2) = 4
La complexité de cet algorithme est donc exponentielle
2. Suites non-linéaires de type "diviser pour régner":
a. Principe:
La méthode de diviser pour régner est une méthode qui permet, parfois de trouver des solutions efficaces à des problèmes
algorithmiques. Elle se fait en trois étapes :
ü 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 : combiner les différents résultats obtenus pour obtenir une solution au problème initial.

Avec ce paradigme, la complexité d’un algorithme traitant des données de taille n s’écrit souvent :
>
C n =a C + f n et C n4 = c
}

• n est la taille du problème initial.

• a est le nombre de sous-problèmes.
3
• 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.

b. Théorème général :
Soit C(n) une fonction définie par l’équation de récurrence suivante :
3
C(n) = a C ( ) + c 𝑛t + d
ˆ

• si a > 𝑏 t alors C(n)= O ( 𝑛Š‹Œ• (Ž) )

• si a = 𝑏 t alors C(n) =O (𝑛t 𝑙𝑜𝑔ˆ (𝑛))
• si a < 𝑏 t alors C(n) =O (𝑛t )

ü Exemple : Recherche Dichotomique récursive

Complexité :
def dicho(l, x, d, f):
if d > f: On a :
return False 3
T(n) = O(1) + T ( ) et T(0) = O(1)
[
else:
m = (d + f) // 2 On a : a=1 et b=2, f(n)=O(1) donc k = 0 et a = bk = 1
if l[m] = = x: D’où d’après le théorème général :
return True
T(n) = O (𝑙𝑜𝑔[ (𝑛))
else:
if x < l[m]:
return dicho(l,x,d,m-1)
else:
return dicho(l,x,m+1,f)
Najlàa ESSALHI 2021-2022 CPGE Mohamed V-Casablanca

3. Résolution par substitution répétitive

Une autre façon de résoudre une équation de récurrence est de substituer, de façon répétitive, la définition de la fonction dans
le coté droit de son équation jusqu’à ce qu’une forme simple soit obtenue.

ü Exemple 1 : fonction factorielle récursive :

On a :
T(n) = T (n − 1) + 2 pour n > 1
T(0) = 1 T(1) = 1
En substituant à chaque fois dans la récurrence on obtient :
T(n) = T (n − 1) + 2 = [T (n − 2) + 2] + 2 (j’ai « +2 » 2 fois)
= [[T (n − 3) + 2] + 2] + 2 (j’ai « +2 » 3 fois)
= …………
= T (n-k) + 2 + ... + 2 + 2 + 2 (j’ai « +2 » k fois)
= …………
= T(1) + 2 + ... + 2 + 2 + 2 (j’ai « +2 » n-1 fois)
3@'
= 1+ %&' 2 = 1+ 2 (n-1) = O (n)

ü Exemple 2 :

On a :
T(n) = T (n − 1) + n, pour n > 1
T(1) = 1
T(n) = T (n − 1) + n = [T(n − 2) + (n − 1)] + n
= [[T (n − 3) + (n − 2)] + (n − 1)] + n
= …………………
= T(1) + 2 + ... + (n − 2) + (n − 1) + n
= 1+2+ ... + (n − 2) + (n − 1) + n
3 3(3 2 ')
= %&' 𝑖 = = O (n2)
[

ü Exemple 3 :
Soit :
3
T(n) = n + 2 T ( ) et T(1) = 1
[
3 3 3
Donc T ( ) = + 2 T ( )
[ [ [“

On substituant d’une façon répétitive jusqu'à arriver au cas de base T(1), c'est-à-dire à une étape k qui vérifie
3
= 1 donc à l’étape k= log [ (𝑛):
[p
3
T(n) =n+2T( )
[
Najlàa ESSALHI 2021-2022 CPGE Mohamed V-Casablanca

3 3 3
= n+ 2 ( + 2 T ( )) = 2 n + 2[ T ( )
[ [“ [“
3 3 3
= 2 n + 2[ ( +2T( )) = 3 n + 2• T ( )
[“ [” [”

= ……………….
3 3 3
= (i-1) n + 2(%@') ( +2T( )) = i n + 2% T ( )
[(•mn) [• [•

= ……………….
3 3 3
= (k-1) n + 2(t@') ( +2T( )) = k n + 2t T ( )
[(pmn) [p [p

= n log [ (𝑛) + 2Š‹Œ“ (3) 𝑇(1)

= 𝑛 𝑙𝑜𝑔[ (𝑛) + 𝑛 = O ( n log [ (𝑛))

4. Résolution par induction

Cette méthode consiste à deviner la solution, et puis de la démontrer à l’aide du principe de récurrence.
Exemple :
>
On a : C(n) = 1 + C ( ) et C(1) = 1
[

Montrer par induction que : C(n) = 1 + log [ (n)

> >
• Supposant que C(m) = log [ (m) + 1 pour toute m < 𝑛 alors : C ( ) = log [ ( ) + 1
[ [

On a donc :
n n
C(n) = 1 + C ( ) = 1 + log [ + 1 = 2 + log [ (n) − log [ 2 = 1 + log [ (n)
2 2
• Il reste à vérifier le cas de base : C 1 = 1 = 1 + log [ (1)
Donc pour toute n ≥ 1 on a: C n = 1 + log [ n = O (log [ (n))

VI. Complexité spatiale :

De la même façon qu’on définit la complexité temporelle d’un algorithme pour évaluer ses performances en temps de calcul,
on peut définir sa complexité spatiale pour évaluer sa consommation en espace mémoire.
Le principe est le même sauf qu’ici on cherche à évaluer l’ordre de grandeur du volume en mémoire utilisé : il ne s’agit pas
d’évaluer précisément combien d’octets sont consommés par un algorithme mais de préciser son taux de croissance (ordre de
grandeur) en fonction de la taille de l’entrée.
• Les variables simples (entiers, booléens, flottants) occupent un espace constant O(1) qui ne dépend pas de l'entrée
• La taille d’un tableau est en grand O du produit de ces dimensions :
o Un tableau à une dimension de N éléments est en O(N)
o Une matrice NxM est en O(NM)
• Les chaînes de caractères sont en grand O de leur longueur.