Chapitre 1

Complexité Algorithmique
CPGE Ibn Timiya

MP/MP* - Informatique
1
Marrakech
mohamedaatila350@gmail.com
A.Mohamed 1 / 34 September 11, 2024 1 / 34

Définitions et notions de base
Plan :
1 Définitions et notions de base

Définitions
2 La complexité
Complexité
Différentes mesures de complexité
Règles de calculs sur la complexité
3 Notation de Landau
Notation O (respectivement Ω)

Définitions et notions de base
Exercice
Exercice
Écrire par deux méthodes différentes une fonction qui prend en paramètre un entier
positif non nul n et qui calcule le nieme terme de la suite de Fibonacci.
F0 = 0
F1 = 1
Fn = Fn−1 + Fn−2
Comparer les deux programmes!.

Définitions et notions de base Définitions
Algorithme
C’est quoi un Algorithme à votre avis?

Algorithme
Un algorithme est une ”Procédure de calcul bien définie qui prend en entrée une valeur,
ou un ensemble de valeurs, et qui donne en sortie une valeur, ou un ensemble de valeurs.
C’est une séquence d’étapes de calcul qui transforment l’entrée en sortie.

Programme
- C’est quoi un programme?

- Qu’est-ce qui fait dire qu’un programme ou un algorithme est bien efficace qu’un autre?
- Avant donc de répondre à cette question, il faut tout d’abord que nos algorithmes à
comparer soient comment?

Algorithme fonctionnel
Dire qu’un algorithme est fonctionnel est équivalent à répondre aux questions suivantes:
— L’algorithme se termine-t-il?
— Le résultat retourné est-il exacte?

La complexité
Plan :

Définitions
2 La complexité
Complexité

La complexité Complexité
complexité
Pour juger donc l’efficacité des algorithmes, on s’intéresse alors à la quantité des
ressources qu’ils exigent. Cette quantité est appelée Complexité.
La complexité intervient alors pour comparer deux algorithmes corrects répondant à la
même question.
Cette complexité peut être divisée en deux types:

complexité
même question.
— Complexité en temps (temporelle)

complexité
même question.
— Complexité en mémoire (spatiale)

complexité
même question.
— Complexité en mémoire (spatiale)
Laquelle de ces deux complexités est bien intéressante que l’autre ?

La complexité Différentes mesures de complexité
Mesures de complexité
On considère les mesures de complexités suivantes :

Meilleur cas (cas le plus favorable): C’est la valeur minimale de la complexité d’un
algorithme mesurée sur toutes les entrées possibles.

Cas moyenne : la valeur moyenne de la complexité en considérant toutes les entrées
possibles

Cas moyenne : la valeur moyenne de la complexité en considérant toutes les entrées
possibles
Le pire des cas (cas le plus défavorable) : Considère la complexité maximale de
l’algorithme sur toutes les entrées possibles.

On définit les trois mesures de complexité sur l’ensemble Dn des données de taille n
comme suit:
Notons cout(d) la complexité en temps de l’algorithme A sur la donnée d,
— La complexité dans le meilleur des cas: MinA (n) = min{coutA (d) | d ∈ Dn }
— La complexité dans le pire des cas: MaxA (n) = max{coutA (d) | d ∈ Dn }}
P
— La complexité en moyenne: MoyA (n) = d∈Dn p(d) × coutA (d)}
où p(d) est la probabilité que l’on ait la donnée d en entrée de l’algorithme.

Exemple de calcul de complexité
Soit le tableau suivant:
10 3 11 5 1 13 2 12 8 4 9 7 6
Exercice
On souhaite chercher un nombre existant dans la liste en utilisant une recherche
séquentielle.
Proposer un programme qui nous permet de retourner l’indice du nombre cherché dans la
liste.
— Complexité dans le meilleur des cas : ?

10 3 11 5 1 13 2 12 8 4 9 7 6
Exercice
séquentielle.
liste.
— Complexité dans le meilleur des cas : ? MinA (n) = 1

— Complexité dans le pire des cas :?

10 3 11 5 1 13 2 12 8 4 9 7 6
Exercice
séquentielle.
liste.

— Complexité dans le pire des cas :? MaxA (n) = n
— complexité moyenne : ?

10 3 11 5 1 13 2 12 8 4 9 7 6
Exercice
séquentielle.
liste.

— Complexité dans le pire des cas :? MaxA (n) = n
1P 1 Pn n+1
— complexité moyenne : ? MoyA (n) = coutA (d) = i=
n d∈Dn n i=1 2

La complexité Règles de calculs sur la complexité
Opérations élémentaires
Pour déterminer le coût d’un algorithme, on se fonde en général sur le modèle de
complexité suivant :
Une affectation, une comparaison ou l’évaluation d’une opération arithmétique ayant en
général un faible temps d’exécution, celui-ci sera considéré comme l’unité de mesure du
coût d’un algorithme.

Somme de complexités
Le coût des instructions p et q en séquence est la somme des coûts de l’instruction p et
de l’instruction q:
La complexité totale vaut T (n) = T1 (n) + T2 (n).
exemple
Programme K:
instruction q : A = 5
instruction p : B = 10
Coût du programme K = Coût(p) + Coût(q)

complexité et structure alternative
Exemple:
if Condition :
Traitement 1
else :
Traitement 2
Complexité dans le pire des cas?

Exemple:
if Condition :
Traitement 1
else :
Traitement 2
T(n)=Coût(condition)+max{Coût(Traitement1), Coût(Traitement2)}

Exemple:
if Condition :
Traitement 1
else :
Traitement 2
T(n)=Coût(condition)+max{Coût(Traitement1), Coût(Traitement2)}
Cas favorable T (n) = Co^

ut(condition) + min{T1 (n), T2 (n)}.
Cas défavorable T (n) = Co^

ut(condition) + max{T1 (n), T2 (n)}.

complexité et structure répétitive: La boucle while
le coût d’un programme f écrit en boucle while est:

X
cout(f ) = (co^
ut(Comparaison) + co^
ut(xi ))
tel que xi représente le coût de chaque instruction élémentaire dans la boucle while.
boucle while
while n >= 0:
T +=1
n -=1

complexité et structure répétitive: La boucle while
le coût d’un programme f écrit en boucle while est:

X
cout(f ) = (co^
ut(Comparaison) + co^
ut(xi ))
tel que xi représente le coût de chaque instruction élémentaire dans la boucle while.
boucle while
while n >= 0:
T +=1
n -=1
Nous avons donc n + 1 répétition, et pour chacune nous avons 5 opérations élémentaires,
d’où T (n) = 5n + 5

complexité et structure répétitive: La boucle for
une initialisation qui s’éxecute une seule fois

une instruction d’incrémentation et une autre de comparaison du compteur
s’éxecutent p fois.
X
cout(f ) = 1 + p ∗ (co^ut(xi ) + 2)
tel que xi représente le coût de chaque instruction élémentaire dans la boucle for et p est
le nombre de répétitions de la boucle for .
boucle for
for i in range(n) :
print(”Bonjour”)

complexité et structure répétitive: La boucle for
une initialisation qui s’éxecute une seule fois

une instruction d’incrémentation et une autre de comparaison du compteur
s’éxecutent p fois.
X
cout(f ) = 1 + p ∗ (co^ut(xi ) + 2)
tel que xi représente le coût de chaque instruction élémentaire dans la boucle for et p est
le nombre de répétitions de la boucle for .
boucle for
for i in range(n) :
print(”Bonjour”)
Nous avons donc n répétitions, avec une instruction élémentaire de complexité constante
O(1), d’où T (n) = 3n + 1

Application
Donner le coût des programmes suivants:

nb = int ( input ( ’ Donnez le nombre de livres : ’) )
if nb <10 :
prix = nb *10
else :
prix = nb *9
print ( ’ Le prix total est : ’ , prix )

Application
Donner le coût des programmes suivants:

nb = int ( input ( ’ Donnez le nombre de livres : ’) )
if nb <10 :
prix = nb *10
else :
prix = nb *9
print ( ’ Le prix total est : ’ , prix )
solution
1 multiplication (lignes 3 ou 5)
3 affectations de variables (lignes 1, puis 3 ou 5)
1 lecture et 1 écriture
1 test (ligne 2)
Au total 7 opérations, donc une complexité constante.

Application
Donner la complexité du programme suivant:

n = int ( input ( " Donnez un entier : " ) )
k = int ( input ( " Donnez un entier : " ) )
Total =0
for i in range ( k ) :
while n >0 :
Total += n * k
n -=1
print ( Total )

Application
Donner la complexité du programme suivant:

n = int ( input ( " Donnez un entier : " ) )
k = int ( input ( " Donnez un entier : " ) )
Total =0
for i in range ( k ) :
while n >0 :
Total += n * k
n -=1
print ( Total )
solution
1 boucle for qui se répète k fois
1 boucle while de n répétition pour chaque i
1 Des opérations d’affectation et de lecture et d’écriture.
La complexité est donc T(n)= n*k + cst.

Exercice
Exercice 1
Proposer un programme qui demande à l’utilisateur d’entrer un nombre positif non nul n
, et qui donne la table de multiplication des nombres de 1 jusqu’à n. Donner sa
complexité en fonction de n

Exercice
Exercice 1
Proposer un programme qui demande à l’utilisateur d’entrer un nombre positif non nul n
, et qui donne la table de multiplication des nombres de 1 jusqu’à n. Donner sa
complexité en fonction de n
Exercice 2
Écrire une fonction qui prend en paramètre un nombre positif non nul, et qui retourne si
ce nombre est un nombre parfait.
Un nombre est parfait s’il est égal à la somme de ses diviseurs propres.
Donner sa complexité.

solution 2
# version 2
def est_parfait ( n ) :
somme_diviseu rs = 1
for i in range (2 , n ) :
if n % i == 0:
s om me _d i vi se ur s += i
if n == somme_ d iv is eu r s :
return True
else :
return False
Complexité ?

solution 1
# Version 1
from math import *
for i in range (2 , n /2 + 1) :
if n % i == 0:
return True
else :
return False
Complexité ?

solution 3
# version 3
for i in range (2 , int ( round ( n **0.5) ) +1) :
if n % i == 0:
s om me _d i vi se ur s += n / i
return True
else :
return False
Complexité ?

Exercice
Exercice
Écrire par deux méthodes différentes (une par un tableau, une par des simples variables)
une fonction qui prend en paramètre un entier positif non nul n et qui calcule le nieme
terme de la suite de Fibonacci.
F0 = 0
F1 = 1
Fn = Fn−1 + Fn−2
Pour chaque méthode, calculer sa complexité spatiale et temporelle.

solution 1
# !/ usr / bin / env python2

# -* - coding : utf -8 -* -
def fibo1 ( n ) :
if (n >=0) :
if n ==0:
return 0
elif n ==1:
return 1
else :
T =[0 ,1]
for i in range (2 , n +1) :
T . append ( T [i -1]+ T [i -2])
return T [ n ]
Complexité spatiale:?

solution 1

# -* - coding : utf -8 -* -
def fibo1 ( n ) :
if (n >=0) :
if n ==0:
return 0
elif n ==1:
return 1
else :
T =[0 ,1]
T . append ( T [i -1]+ T [i -2])
return T [ n ]
Complexité spatiale:? n + 1
Complexité temporelle: ?

solution 1

# -* - coding : utf -8 -* -
def fibo1 ( n ) :
if (n >=0) :
if n ==0:
return 0
elif n ==1:
return 1
else :
T =[0 ,1]
T . append ( T [i -1]+ T [i -2])
return T [ n ]
Complexité spatiale:? n + 1
Complexité temporelle: ? n − 1 additions

solution 2

# -* - coding : utf -8 -* -
def fibo1 ( n ) :
if (n >=0) :
if n ==0:
return 0
elif n ==1:
return 1
else :
a =0
b =1
c =0
c=b+a
a=b
b=c
return c

solution 2

# -* - coding : utf -8 -* -
def fibo1 ( n ) :
if (n >=0) :
if n ==0:
return 0
elif n ==1:
return 1
else :
a =0
b =1
c =0
c=b+a
a=b
b=c
return c
Complexité spatiale:? 3

solution 2

# -* - coding : utf -8 -* -
def fibo1 ( n ) :
if (n >=0) :
if n ==0:
return 0
elif n ==1:
return 1
else :
a =0
b =1
c =0
c=b+a
a=b
b=c
return c
Complexité temporelle: ? n − 1 additions

solution 3

# -* - coding : utf -8 -* -
def fibo1 ( n ) :
if (n >=0) :
if n ==0:
return 0
elif n ==1:
return 1
else :
a =0
b =1
for i in range (2 , n //2 +2) :
a=b+a
b=a+b
if n %2==0:
return a
else :
return b

solution 3

# -* - coding : utf -8 -* -
def fibo1 ( n ) :
if (n >=0) :
if n ==0:
return 0
elif n ==1:
return 1
else :
a =0
b =1
for i in range (2 , n //2 +2) :
a=b+a
b=a+b
if n %2==0:
return a
else :
return b

solution 3

# -* - coding : utf -8 -* -
def fibo1 ( n ) :
if (n >=0) :
if n ==0:
return 0
elif n ==1:
return 1
else :
a =0
b =1
for i in range (2 , n //2 +2) :
a=b+a
b=a+b
if n %2==0:
return a
else :
return b
Complexité temporelle: ? n/2 additions

Notation de Landau
Plan :

Définitions
2 La complexité
Complexité

Notation de Landau Notation O (respectivement Ω)
La notation la plus utilisée pour noter la complexité d’un algorithme est la notation O
(respectivement Ω), qui dénote un ordre de grandeur. Par exemple, on dira d’un
algorithme qu’il est O(10) (respectivement Ω(10)) s’il nécessite au plus (respectivement
au moins) 10 opérations dans le pire cas (respectivement dans le meilleur des cas) pour
se compléter.

Big O

Big Ω


Quelques complexités utiles

Exercice
Exercice1
Répondre par (Vrai, Faux) aux propositions suivantes en justifiant:
T (n) = 3n + 6 ∈ O(n)
n2 + 3n ∈ O(n2 );
3n2 ∈ O(2n );
3n2 ∈ Ω(n2 );
3n2 ∈ Θ(n2 );
Exercice 2
Pour convertir un nombre entier positif N de la base décimale à la base binaire, il faut
opérer par des divisions successives du nombre N par 2. Les restes des divisions
constituent la représentation binaire.
Écrire une fonction itérative Binaire(N) permettant d’imprimer à l’écran la
représentation binaire d’un nombre N;
Donner sa complexité spatiale et temporelle.

Chapitre 1

Transféré par

Informations du documentcliquez pour développer les informations du document

Informations du documentcliquez pour développer les informations du document

Droits d'auteur :

Formats disponibles

Chapitre 1

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

Chapitre 1

Transféré par

Droits d'auteur :

Formats disponibles

Complexité Algorithmique

CPGE Ibn Timiya

A.Mohamed 1 / 34 September 11, 2024 1 / 34

1 Définitions et notions de base

A.Mohamed 2 / 34 September 11, 2024 2 / 34

A.Mohamed 3 / 34 September 11, 2024 3 / 34

C’est quoi un Algorithme à votre avis?

A.Mohamed 4 / 34 September 11, 2024 4 / 34

ou un ensemble de valeurs, et qui donne en sortie une valeur, ou un ensemble de valeurs.

C’est une séquence d’étapes de calcul qui transforment l’entrée en sortie.

A.Mohamed 5 / 34 September 11, 2024 5 / 34

- C’est quoi un programme?

A.Mohamed 6 / 34 September 11, 2024 6 / 34

— Le résultat retourné est-il exacte?

A.Mohamed 7 / 34 September 11, 2024 7 / 34

1 Définitions et notions de base

A.Mohamed 8 / 34 September 11, 2024 8 / 34

ressources qu’ils exigent. Cette quantité est appelée Complexité.

La complexité intervient alors pour comparer deux algorithmes corrects répondant à la

Cette complexité peut être divisée en deux types:

A.Mohamed 9 / 34 September 11, 2024 9 / 34

ressources qu’ils exigent. Cette quantité est appelée Complexité.

La complexité intervient alors pour comparer deux algorithmes corrects répondant à la

Cette complexité peut être divisée en deux types:

— Complexité en temps (temporelle)

A.Mohamed 9 / 34 September 11, 2024 9 / 34

ressources qu’ils exigent. Cette quantité est appelée Complexité.

La complexité intervient alors pour comparer deux algorithmes corrects répondant à la

Cette complexité peut être divisée en deux types:

— Complexité en temps (temporelle)

— Complexité en mémoire (spatiale)

A.Mohamed 9 / 34 September 11, 2024 9 / 34

ressources qu’ils exigent. Cette quantité est appelée Complexité.

La complexité intervient alors pour comparer deux algorithmes corrects répondant à la

Cette complexité peut être divisée en deux types:

— Complexité en temps (temporelle)

— Complexité en mémoire (spatiale)

Laquelle de ces deux complexités est bien intéressante que l’autre ?

A.Mohamed 9 / 34 September 11, 2024 9 / 34

On considère les mesures de complexités suivantes :

A.Mohamed 10 / 34 September 11, 2024 10 / 34

On considère les mesures de complexités suivantes :

algorithme mesurée sur toutes les entrées possibles.

A.Mohamed 10 / 34 September 11, 2024 10 / 34

On considère les mesures de complexités suivantes :

algorithme mesurée sur toutes les entrées possibles.

Cas moyenne : la valeur moyenne de la complexité en considérant toutes les entrées

A.Mohamed 10 / 34 September 11, 2024 10 / 34

On considère les mesures de complexités suivantes :

algorithme mesurée sur toutes les entrées possibles.

Cas moyenne : la valeur moyenne de la complexité en considérant toutes les entrées

Le pire des cas (cas le plus défavorable) : Considère la complexité maximale de

l’algorithme sur toutes les entrées possibles.

A.Mohamed 10 / 34 September 11, 2024 10 / 34

A.Mohamed 11 / 34 September 11, 2024 11 / 34

Exemple de calcul de complexité

Soit le tableau suivant: