Complexite Slides PDF

Complexité
1/53 Complexité 1/
1 Introduction
2 Opérations élémentaires
Présentation
Un mot sur la racine carrée
3 Exemples de complexités de fonctions récursives

Récurrences Cn = Cn−1 + 1 et Cn = Cn−1 + n
Stratégie diviser pour régner
Tri fusion
Introduction
1 Introduction
Présentation

Tri fusion
Introduction
Crédits
1 Option informatique MPSI, MP/MP* , Roger Mansuy, paru chez

Vuibert.
Introduction
Crédits

Vuibert.
2 Cours diviser pour régner , Becirspahic
Introduction
Crédits

Vuibert.
2 Cours diviser pour régner , Becirspahic
3 Wikipédia : Analyse de la compléxité des algorithmes.
Introduction
Définition
L’analyse de la complexité d’un algorithme consiste en l’étude formelle de

la quantité de ressources (par exemple de temps ou d’espace) nécessaire à
l’exécution de cet algorithme.
En temps Il s’agit de savoir si une fonction termine dans un temps
raisonnable.
Introduction
Définition
L’analyse de la complexité d’un algorithme consiste en l’étude formelle de

la quantité de ressources (par exemple de temps ou d’espace) nécessaire à
l’exécution de cet algorithme.
En temps Il s’agit de savoir si une fonction termine dans un temps
raisonnable.
En mémoire Il s’agit de déterminer si la fonction dispose bien de
toutes les ressources physiques pour s’exécuter.
Introduction
Temps et espace
Soit f un programme prenant en paramètre une donnée d

Complexité en espace pour une donnée d : déterminer la place en
mémoire en plus de d occupée par le programme.
Introduction
Temps et espace

Complexité en temps pour une donnée d : dénombrer toutes les
opérations élémentaires effectuées lors de l’appel f (d) et faire la
somme de la durée de chacune.
Introduction
Temps et espace

Complexité en temps pour une donnée d : dénombrer toutes les
opérations élémentaires effectuées lors de l’appel f (d) et faire la
somme de la durée de chacune.
Parfois, on ne s’intéresse qu’à certaines opérations bien définies (ça
dépend de ce qu’on veut étudier).
Introduction
Définition
Définition
Notons Dn l’ensemble des données de taille n et C (d) la complexité d’un
certain programme pour une donnée d.
1 La complexité dans le pire cas est Cmax (n) = max C (d)
d∈Dn
Introduction
Définition
Définition
d∈Dn
2 La complexité dans le meilleur cas est Cmin (n) = min C (d)
d∈Dn
Introduction
Définition
Définition
d∈Dn
2 La complexité dans le meilleur cas est Cmin (n) = min C (d)
d∈Dn
X
3 La complexité en moyenne est Cmoy (n) = P(d)C (d) où P
d∈Dn
désigne la loi de probabilité associée à l’apparition des données de
taille n.
Introduction
Landau
Définition
Soient U = (un ) et V = (vn ) deux suites réelles positives. On dit que :
1 U est dominée par V si il existe λ ∈ R+ et N ∈ N tels que pour tout
n ∈ N, si n ≥ N alors un ≤ λvn . On le note un = O(vn ).
On dit aussi que V domine U.
Introduction
Landau
Définition
1 U est dominée par V si il existe λ ∈ R+ et N ∈ N tels que pour tout
n ∈ N, si n ≥ N alors un ≤ λvn . On le note un = O(vn ).
On dit aussi que V domine U.
2 U et V sont de même ordre (de grandeur) si U domine V et V
domine U (i.e. un = O(vn ) et vn = O(un )). On le note un = Θ(vn )
( un est en grand theta de vn ).
Introduction
Landau
Définition
1 On écrit un = Ω(vn ) ( un est en grand Omega de vn ) si il existe
λ ∈ R+ et N ∈ N tels que pour tout n ∈ N, si n ≥ N alors un ≥ λvn .
Observons que dans ce cas λ1 un ≥ vn et donc
un = Ω(vn ) ⇐⇒ vn = O(un ).
Remarque
Si un ∼ vn alors un = Θ(vn ).
Introduction
Landau
Définition
1 On écrit un = Ω(vn ) ( un est en grand Omega de vn ) si il existe
λ ∈ R+ et N ∈ N tels que pour tout n ∈ N, si n ≥ N alors un ≥ λvn .
Observons que dans ce cas λ1 un ≥ vn et donc
un = Ω(vn ) ⇐⇒ vn = O(un ).
2 U et V sont dites équivalentes si et seulement si vn 6= 0 APCR et
un
−→ 1.
vn n→+∞
Cette définition (qui nous suffit) est plus restrictive que celle du cours
de maths.
Remarque
Si un ∼ vn alors un = Θ(vn ).
Introduction
Ordres de grandeur
Pour une donnée de taille n :

Dénomination Définition Exemple
logarithmique O(log(n)) Recherche dans une liste triée (pire
linéaire Θ(n) Inversion d’une liste
quasi-linéaire Θ(n log(n)) Tri fusion
polynomiale O(n2 ) Tri par insertion (pire cas)
polynomiale Θ(nk ) pour un k > 1 produit matriciel naı̈f en Θ(n3 )
exponentielle O(αn ) pour un α > 1 Satisfiabilité d’une formule (pire ca
10/53 Complexité 10 /
Introduction
Que compter ?
La plupart du temps, on se contente de donner une majoration à

constante multiplicative près du temps de calcul. On ne compte pas
précisément le nombre d’opérations élémentaires (est-ce bien malin de
mettre dans le même sac un accès à un élément de tableau et une
addition binaire ?).
Dans ce cas, la notation en O(f (n)) (si n est l’entrée) nous suffit.
Parfois, on s’intéresse à une opération spécifique, et dans ce cas un
décompte précis est favorisé. Exemple :
nombre d’échanges d’éléments dans un tri de tableau ;
nombre de produits de flottants dans un produit matriciel optimisé .
Opérations élémentaires
1 Introduction
Présentation

Tri fusion
Opérations élémentaires Présentation
1 Introduction
Présentation

Tri fusion
Pour mesurer le temps d’exécution d’un programme, on utilise le
nombre d’opérations élémentaires à effectuer plutôt qu’une durée en
seconde. En général on en cherche une majoration, plus rarement une
minoration.
minoration.
La raison est que le même programme s’exécutera plus ou moins vite
selon la machine mais que le nombre d’opérations ne changera pas.
minoration.
Les opérations suivantes sont dites élémentaires
1 +; −; / ; / ; ∗ ; % // op é r a t i o n s s u r l e s nombres
2 a = . . . . ; r e t u r n // a f f e c t a t i o n , r e t o u r n e r , a f f i c h e r
3 t [ i ] # a c c è s
4 . . . < . . . ; . . . == . . . ; // c o m p a r a i s o n s de nombres
5 f r e e ( t ) // l i b é r a t i o n
6
Il y en a d’autres que nous dévoilerons au fur et à mesure.
minoration.
Les opérations suivantes sont dites élémentaires
1 +; −; / ; / ; ∗ ; % // op é r a t i o n s s u r l e s nombres
2 a = . . . . ; r e t u r n // a f f e c t a t i o n , r e t o u r n e r , a f f i c h e r
3 t [ i ] # a c c è s
4 . . . < . . . ; . . . == . . . ; // c o m p a r a i s o n s de nombres
5 f r e e ( t ) // l i b é r a t i o n
6
Il y en a d’autres que nous dévoilerons au fur et à mesure.

Complexité temporelle d’un programme au pire : nombre max. d’op.
elem. à effectuer (en fonction de la taille du ou des arguments).
Exemple introductif
On cherche les diviseurs d’un entier n :

1 void d i v i s e u r s 1 ( i n t n) :
2 f o r ( i n t i =2 ; i<n ; i++) {
3 i f ( n % i == 0 ) {
4 p r i n t f ( ”%d ; ” i ) ; // compt é comme O( 1 )
5 }
6
Exemple introductif

2 f o r ( i n t i =2 ; i<n ; i++) {
3 i f ( n % i == 0 ) {
5 }
6
Ce programme effectue exactement n − 2 calculs de restes de

divisions euclidiennes, n − 2 comparaisons et un nombre d’affichages
inférieur ou égal à n − 2.
Au maximum, il y a donc 5(n − 2) + 1 opérations élémentaires plus
les n − 2 incrémentations de i + compraisons.
Exemple introductif

2 f o r ( i n t i =2 ; i<n ; i++) {
3 i f ( n % i == 0 ) {
5 }
6
Ce programme effectue exactement n − 2 calculs de restes de

divisions euclidiennes, n − 2 comparaisons et un nombre d’affichages
inférieur ou égal à n − 2.
Au maximum, il y a donc 5(n − 2) + 1 opérations élémentaires plus
les n − 2 incrémentations de i + compraisons.
L’ordre de grandeur est donc donné par une application affine : On dit
que la complexité temporelle est en O(n)
Exemple introductif (2)

√ √
Si n = pq avec p ≥ n, alors q ≤ n.

√ √
Nouveau principe : on cherche tous les diviseurs q qui sont plus petits
√ n
que n ; les autres valent .
q

√ √
Nouveau principe : on cherche tous les diviseurs q qui sont plus petits
√ n
que n ; les autres valent .
q
On entre :
2 i n t q ; i n t p ; // 2 op
3 q=1 ; // 1 op
4 w h i l e ( q∗q <=n ) { // 2 op
5 i f ( n % q == 0 ) { // 2 o p s
6 p r i n t f ( ”%d” , q ) ; // 1 op
7 p=n/q ; // 2 op
8 i f ( p != q ) // ( ne p a s a f f i c h e r q 2 f o i s s i n=p ˆ 2 )
: 1 op
9 p r i n t ( p ) ; // 1 op
10 q=q+1 ; // 2 op
11 }
12 }
13
√
n itérations au plus, moins de 20 op. elem. par passage.
√
n itérations au plus, moins de 20 op. elem. par passage.
√ √
En tout pas plus de 3 + 20 n opérations élémentaires . O( n).
Taille du problème
Déterminer le temps d’exécution en fonction de la taille du problème.

Exemple : recherche de diviseur de n. La taille est n, le temps
√
d’exécution est proportionnel à n ou n.

√
Exemple : manipulation d’une liste. Taille du problème : nombre
d’éléments.

√
d’éléments.
Exemple : traitement d’un fichier texte. Taille du problème : nombre
de caractères.

√
d’éléments.
de caractères.
Addition de matrices n × m. Taille du problème le couple (n, m) ou nm

√
d’éléments.
de caractères.
Recherche d’un mot dans un fichier. Taille du problème le couple
(n, m) où n est le nombre de caractères du texte et m celui du mot.

√
d’éléments.
de caractères.
Compression d’images : une image n’est rien de plus qu’une matrice
w × h de pixels. La taille du problème est (w , h).

√
d’éléments.
de caractères.
Compression d’images : une image n’est rien de plus qu’une matrice
w × h de pixels. La taille du problème est (w , h).
Souvent, la taille du problème est indiquée dans l’énoncé.
Modèle de complexité temporelle impérative
La complexité d’un algorithme est une fonction C définie inductivement.

On ne mesure pas le temps d’exécution d’un programme en secondes
mais le nombre d’opérations élémentaires.

Opérations de base . On considère qu’elles ont toutes le même
coût.

coût.
Séquences : Le coût des instructions p; q en séquence est la somme
des coûts de l’instruction p et de l’instruction q : C (p) + C (q)

coût.
Séquences : Le coût des instructions p; q en séquence est la somme
des coûts de l’instruction p et de l’instruction q : C (p) + C (q)
Tests : Le coût d’une expression conditionnelle
if (b) {p;} else {q;} est inférieur ou égal au maximum des
coûts des instructions p et q , plus un test plus ou moins compliqué
(temps d’évaluation de l’expression b ). max(C (p), C (q)) + C (b).
En général, on a C (b) = O(1)et on le néglige. Mais ce n’est pas
toujours vrai.
Modèle pour la complexité temporelle

Le coût d’une boucle for(i=0;i<m;i++) p; est m fois le coût de
l’instruction p si ce coût ne dépend pas de la valeur de i :
1 + m(C (p) + 2) = O(mC (p)) ( +2 pour l’incrémentation et
comparaison, 1 : init).

Quand le coût du corps de la boucle dépend de la valeur du compteur
i , le coût total de la boucle est la somme des coûts du corps de la
boucle pour chaque valeur de i , plus l’incrémentation :
Pm−1 Pm−1
i=0 (C (pi ) + 2) = O( i=0 C (pi )).
Le coût d’une boucle for ne peut pas être inférieur à O(m) car il y
a toujours l’incrémentation du compteur sauf si dans le corps de
boucle se trouve une instruction d’arrêt ou de retour.

Quand le coût du corps de la boucle dépend de la valeur du compteur
i , le coût total de la boucle est la somme des coûts du corps de la
boucle pour chaque valeur de i , plus l’incrémentation :
Pm−1 Pm−1
i=0 (C (pi ) + 2) = O( i=0 C (pi )).
Le coût d’une boucle for ne peut pas être inférieur à O(m) car il y
a toujours l’incrémentation du compteur sauf si dans le corps de
boucle se trouve une instruction d’arrêt ou de retour.
Coût d’une instruction while : le nombre d’itérations n’est pas
connu à priori.
On évalue le nombre d’itérations. Puis on applique la même règle que
pour une boucle for en y ajoutant la complexité du test.
Complexité temporelle (cas fonctionnel)
On essaye d’établir une relation de récurrence entre C (n) (la

complexité pour une donnée de taille n) et la complexité des appels
internes plus la complexité hors appel récursif.

Complexité C (n) en nombre de multiplications pour
1 let rec fact n =
2 if n <2 then 1 else n * fact (n -1)

1 let rec fact n =
C (0) = C (1) = 0 ;

1 let rec fact n =
C (0) = C (1) = 0 ;
C (n) = C (n − 1) + 1 : une multiplication seulement dans le cas n ≥ 2.

1 let rec fact n =
C (0) = C (1) = 0 ;
C (n) = C (n − 1) + 1 : une multiplication seulement dans le cas n ≥ 2.
Alors
C (n) = C (n −1)+1 = (C (n −2)+1)+1 = · · · = C (1) +n −1 = O(n)

| {z }
cte

Complexité C (n) en nombre d’opérations élémentaires pour
1 let rec fact n =

1 let rec fact n =
C (0) = C (1) = 1 (une comparaison n<2 ). En fait, on pourrait aussi

compter l’opération d’écriture à l’adresse de retour et d’autres
opérations cachées, mais ce n’est pas si important car on veut un
comportement assymptotique.

1 let rec fact n =

C (n) = C (n − 1) + 3 (on compte n<2 ; n-1 ; n * .. ).

1 let rec fact n =

Mais cette précision accrue est sans doute superflue, car on obtient le
même ordre de grandeur :
C (n) = C (n−1)+3 = (C (n−2)+3)+3 = · · · = C (1) +3(n−1) = O(n)
| {z }
cte

1 let rec fact n =

Mais cette précision accrue est sans doute superflue, car on obtient le
même ordre de grandeur :
C (n) = C (n−1)+3 = (C (n−2)+3)+3 = · · · = C (1) +3(n−1) = O(n)
| {z }
cte
En général, on ne s’encombre pas avec une trop grande précision. On
fixe C (0) = C (1) = 1 et, si les opérations hors appels récursifs sont en
O(f (n)), on prend le représentant le plus simple (ex : n pour O(n))
limites du modèle
Le modèle de complexité présenté est une approximation de la réalité.
limites du modèle
Le modèle ne tient pas compte du fait que la taille des entiers peut
être grande (surtout vrai en Python). La multiplication de deux très
grands nombres est bien entendu plus coûteuse que celle de 2 ∗ 3.
Il faudra par exemple d’abord lire tous les chiffres des opérandes et
écrire ceux du résultat. Plus toutes les autres opérations logicielles
que Python ajoute au traitement processeur.
limites du modèle
Autre exemple, une très grande liste (ou matrice) ne tiendra pas en
mémoire vive : il faudra faire des accès disques pour parcourir les
éléments.
limites du modèle
éléments.
En CPGE, on convient que malloc(..) est une opération à coût
constant (ce qui est faux). En revanche realloc(..) peut-être
éventuellement en O(1) dans des cas où il n’y a pas de copie à faire.
limites du modèle
éléments.
En CPGE, on convient que malloc(..) est une opération à coût
constant (ce qui est faux). En revanche realloc(..) peut-être
éventuellement en O(1) dans des cas où il n’y a pas de copie à faire.
L’évaluation du temps mis par un algorithme pour s’exécuter est un
domaine de recherche à part entière, car elle se révèle parfois très
difficile.
Meilleur des cas
La complexité au pire est la plus significative, mais il peut être utile

de connaı̂tre aussi la complexité dans le meilleur des cas, pour avoir
une borne inférieure du temps d’exécution d’un algorithme.
Meilleur des cas
La complexité au pire est la plus significative, mais il peut être utile

de connaı̂tre aussi la complexité dans le meilleur des cas, pour avoir
une borne inférieure du temps d’exécution d’un algorithme.
En particulier, si la complexité dans le meilleur et dans le pire des cas
sont du même ordre, cela signifie que le temps d’exécution de
l’algorithme est relativement indépendant des données et ne dépend
que de la taille du problème.
Complexité en moyenne
Parler de moyenne des temps d’exécution n’a de sens que si l’on a une
idée de la fréquence des différentes données possibles pour un même
problème de taille n.
Les calculs de complexité moyenne recourent aux notions définies en
mathématiques dans le cadre de la théorie des probabilités et des
statistiques.
Les calculs de complexité moyenne recourent aux notions définies en
mathématiques dans le cadre de la théorie des probabilités et des
statistiques.
La complexité en moyenne n’est, en général, pas attendue dans les
sujets mais on en verra quelques exemples.
Complexité en espace
Il n’y a pas que le temps d’exécution des algorithmes qui intéresse les
informaticiens.
informaticiens.
Une autre ressource importante en informatique est la mémoire.
informaticiens.
On appelle complexité en espace d’un algorithme la place nécessaire
en mémoire pour faire fonctionner cet algorithme en dehors des
paramètres du programme.
informaticiens.
On appelle complexité en espace d’un algorithme la place nécessaire
en mémoire pour faire fonctionner cet algorithme en dehors des
paramètres du programme.
Elle s’exprime également sous la forme d’un O(f (n)) où n est la taille
du problème.
Complexité en mémoire
En général, il suffit de faire le total des tailles en mémoire des

différentes variables utilisées.

La seule vraie exception à la règle est le cas des fonctions récursives,
qui cachent souvent une complexité en espace élevée du fait de
l’empilement des stack frames.
La récursion terminale est une bonne solution à ce problème.

La seule vraie exception à la règle est le cas des fonctions récursives,
qui cachent souvent une complexité en espace élevée du fait de
l’empilement des stack frames.
La récursion terminale est une bonne solution à ce problème.
La complexité spatiale est nécessairement toujours inférieure (ou
égale) à la complexité temporelle d’un algorithme : on suppose qu’une
opération d’écriture en mémoire prend un temps O(1), donc écrire
une mémoire de taille M prend un temps O(M).
Opérations élémentaires Un mot sur la racine carrée
1 Introduction
Présentation

Tri fusion
Objectif
Les pages qui suivent sont données pour la culture.

Dans cette sous-section, on présente une astuce très utilisée par les
cartes graphiques 3D pour calculer la racine carrée.
Objectif

Les cartes graphiques font en effet beaucoup de calculs géométriques
(par exemple pour déterminer si un projectile rencontre une surface
comme un mur : intersection droite plan).
Objectif

Ces calculs font intervenir des notions comme le vecteur normal à une
surface (il faut diviser un produit vectoriel par une norme, donc la
racine carrée de la somme des carrés des coordonnées du vecteur.
Objectif

Ces calculs font intervenir des notions comme le vecteur normal à une
surface (il faut diviser un produit vectoriel par une norme, donc la
racine carrée de la somme des carrés des coordonnées du vecteur.
D’où l’importance d’un calcul efficace de la racine carrée.
Méthode de Héron
√
Calcul de A
Par dichotomie avec une précision ε en résolvant x 2 − A = 0 sur
[0; A + 1]. Calcul en O(log( A+1
ε )). Ce n’est déjà pas si mal.
√
Calcul de A
Méthode de Héron (une spécialisation de la méthode de Newton à cet
objectif particulier) :
√
Calcul de A
1 A
Choisir x0 initial puis xk+1 = (xk + ).
2 xk
√
Calcul de A
1 A
Choisir x0 initial puis xk+1 = (xk + ).
2 xk
Convergence quadratique : le nombre de chiffres significatifs double à
chaque itération. Au bout de quelques itérations (15 ou 20), on atteint
la précision maximale possible sur un ordinateur de bureau. On peut
alors considérer que le calcul de la racine carrée est quasiment en
temps constant (pas tout à fait).
1
John Carmack et √
A
John Carmack est un informaticien américain à l’origine de nombreux jeux
vidéos, dont Wolfenstein 3D, Doom et Quake.
Les cartes graphiques 3D avec processeur 32 bits (la majorité des
cartes du marché en 2020) utilisent l’astuce de John Carmack et son
√ 1
nombre magique pour calculer, non pas A mais √ .
A
1
John Carmack et √
A
√ 1
A
Le flottant A codé sur 32 bits en A = (−1)0 2e1 (1 + m1 ) est considéré
comme l’entier I1 = 223 (127 + e1 + m1 ) : int i1 = *(int *) &a; .
1
John Carmack et √
A
√ 1
A
Carmack utilise son nombre magique, l’entier codé en hexadécimal
I1
0x5f 3759df (on a trouvé mieux depuis) et lui soustrait b c. Il
2
convertit ensuite cet entier en flottant.
1
John Carmack et √
A
√ 1
A
Carmack utilise son nombre magique, l’entier codé en hexadécimal
I1
0x5f 3759df (on a trouvé mieux depuis) et lui soustrait b c. Il
2
convertit ensuite cet entier en flottant.
Quelle que soit la valeur de A, on peut montrer que le flottant
1
retourné est proche de √ avec une erreur au pire de 2/1000 ! !
A
Complexité temporelle en O(1).
Exemples de complexités de fonctions récursives
1 Introduction
Présentation

Tri fusion
Exemples de complexités de fonctions récursives Récurrences Cn = Cn−1 + 1 et Cn = Cn−1 + n
1 Introduction
Présentation

Tri fusion
Exponentiation naı̈ve
1 let rec pow x n = match n with

2 | 0 -> 1
3 | _ -> x * pow x (n -1) ;;
La complexité (dans tous les cas) est de la forme Cn = Cn−1 + 1 (déjà

étudié pour la factorielle).

2 | 0 -> 1
3 | _ -> x * pow x (n -1) ;;

C’est une suite arithmétique de raison 1.

2 | 0 -> 1
3 | _ -> x * pow x (n -1) ;;

On a donc Cn = Θ(n)

2 | 0 -> 1
3 | _ -> x * pow x (n -1) ;;

On a donc Cn = Θ(n)
A noter que le second membre de la relation de récurrence est 1
puisqu’il y a un nombre d’opérations élémentaires en O(1) (mais pas
égal à 1, le filtrage lui-même coûte quelques opérations). On se
simplifie la vie en prenant le terme le plus simple possible dans la
classe de complexité
Insertion dans une liste triée
1 let rec insert l x = match l with

2 | [] -> [ x ]
3 | y :: q when y > x -> x :: l
4 | y :: q -> y ::( insert q x ) ;;
Hors appel récursif, il faut compter l’ajout en tête de liste (règle 3) et

le filtrage lui-même (il n’a pas un coût nul, bien que constant).

2 | [] -> [ x ]
3 | y :: q when y > x -> x :: l
4 | y :: q -> y ::( insert q x ) ;;

La relation de récurrence pour la complexité au pire est donc
Cn = Cn−1 + O(1) ce que l’on simplifie en Cn = Cn−1 + 1.

2 | [] -> [ x ]
3 | y :: q when y > x -> x :: l
4 | y :: q -> y ::( insert q x ) ;;

Au mieux Cn = 1 (règles de filtrage 1 et 2).

2 | [] -> [ x ]
3 | y :: q when y > x -> x :: l
4 | y :: q -> y ::( insert q x ) ;;

Au mieux Cn = 1 (règles de filtrage 1 et 2).
Complexité au pire O(n) ; au mieux O(1).
Tri par insertion
1 let rec tri l =

2 match l with
3 | [] -> []
4 | x :: q -> insert x ( tri q ) ;;
Insertion dans tri q au pire en O(n) où n = |`|.

Complexité au pire Cn = Cn−1 + n (n pour l’insertion au pire).
Tri par insertion
1 let rec tri l =

2 match l with
3 | [] -> []
4 | x :: q -> insert x ( tri q ) ;;

On a donc Cn − Cn−1 = n. Il vient par télescopage
n
X n
X
Cn − C0 = Ci − Ci−1 = i = O(n2 )
|{z}
cte i=1 i=0
Donc Cn = O(n2 )
Tri par insertion
1 let rec tri l =

2 match l with
3 | [] -> []
4 | x :: q -> insert x ( tri q ) ;;

On a donc Cn − Cn−1 = n. Il vient par télescopage
n
X n
X
Cn − C0 = Ci − Ci−1 = i = O(n2 )
|{z}
cte i=1 i=0
Donc Cn = O(n2 )
Complexité au mieux Cn = Cn−1 + 1. Donc Cn = O(n).
Exemples de complexités de fonctions récursives Stratégie diviser pour régner
1 Introduction
Présentation

Tri fusion
Diviser pour régner

Méthode
découper la donnée que l’on doit traiter en deux parts (ou plus) de
tailles proches ;

Méthode
tailles proches ;
Résoudre le problème sur les parties plus petites ;

Méthode
tailles proches ;
Combiner les résultats obtenus pour construire le résultat
correspondant à la donnée initiale.

Méthode
tailles proches ;
Une donnée de taille n est découpée en deux autres données de tailles

b n2 c et d n2 e

Méthode
tailles proches ;

b n2 c et d n2 e
La complexité obéit à une relation de la forme :
Cn = aCb n2 c + bCd n2 e + f (n)
où (a, b) 6= (0, 0) sont des constantes associées au problème et f (n)
correspond au coût total du partage et de la recombinaison.

Méthode
tailles proches ;

b n2 c et d n2 e
La complexité obéit à une relation de la forme :
Cn = aCb n2 c + bCd n2 e + f (n)
où (a, b) 6= (0, 0) sont des constantes associées au problème et f (n)
correspond au coût total du partage et de la recombinaison.
Une telle récurrence est dite de type diviser pour régner .
Choix du dernier terme
Proposition
Soient a,b deux entiers tels que ab 6= 0 et f , g deux fonctions croissantes
de même ordre de grandeur. Alors les suites (Un ) et (Vn ) telles que
U0 = V0 et pour tout n ∈ N∗ :
Un = aUbn/2c + bUdn/2e + f (n)

Vn = aVbn/2c + bVdn/2e + g (n)
sont du même ordre de grandeur.
Cette proposition (admise) justifie qu’on remplace le dernier terme par un

terme plus simple de même ordre de grandeur (donc 1 pour O(1), n2 pour
O(n2 ) etc.)
Croissance de la complexité en fonction de la taille n de la

donnée.
On considère Un = f (n) + Ubn/2c + Udn/2e . avec f croissante. On pose
U0 = U1 = 1 parce que ça nous arrange et qu’on étudie un comportement
asymptotique.
On montre que Un−1 ≤ Un pour n ≥ 1

donnée.
asymptotique.
Cas de base 1 = U0 ≤ U1 = 1

donnée.
asymptotique.
Hérédité Si Uk ≥ Uq pour tout n > k ≥ q.

donnée.
asymptotique.
Un = f (n) + Ubn/2c + Udn/2e et

donnée.
asymptotique.
Un−1 = f (n − 1) + Ub(n−1)/2c + Ud(n−1)/2e

donnée.
asymptotique.
Un−1 = f (n − 1) + Ub(n−1)/2c + Ud(n−1)/2e
Or, les fonctions parties entières sont croissantes, donc
Ub(n−1)/2c ≤ Ubn/2c et Ud(n−1)/2e ≤ Udn/2e par HR. Et
f (n − 1) ≤ f (n) par hypothèse.

donnée.
asymptotique.
Un−1 = f (n − 1) + Ub(n−1)/2c + Ud(n−1)/2e
Donc Un ≥ Un−1

donnée.
asymptotique.
Un−1 = f (n − 1) + Ub(n−1)/2c + Ud(n−1)/2e
Donc Un ≥ Un−1
Donc (Un ) ↑. En pratique, on ne refait pas cette preuve et on
admet que la complexité est croissante avec la taille des
données.
Quelques observations
Dans ce qui suit stoutes les fonctions sont positives et n ∈ N

ln x
Pour a > 0, ln n = Θ(loga ) car loga x =
ln a
n = Θ(bnc) car pour n > 2
n
< n − 1 < bnc ≤ n
2
(de même n = Θ(dne))
Dichotomie
1 let dicho v x = (* chercher x dans le tableau tri é v *)

2 let rec cherche_entre a b =
3 if a = b then ( x = v .( a ) )
4 else let m = ( a + b ) /2 in
5 if (x > v .( m ) ) then cherche_entre ( m +1) b
6 else cherche_entre a m
7 in cherche_entre 0 ( Array . length v -1) ;;
A chaque étape, la zone de recherche est divisée par deux (on note
n//2 la division euclidienne) :
x x x x x : tableau de taille impaire n
m
les 2 sous-tableaux de taille n//2 ou n//2+1
x x x x : tableau de taille paire n
m
Au moins un sous-tableau de taille n//2
Dichotomie
Hors appels récursifs, il y a un nombre borné d’autres opérations,
toutes en O(1). Le coût total à chaque tour hors appels récursifs est
donc O(1).
Dichotomie
donc O(1).
Pour un tableau de taille n, la complexité au pire est du type
Cn = Cd n2 e + O(1) ; simplifiée en Cn = Cd n2 e + 1 (on cherche dans le
plus grand sous-tableau pour que ce soit le pire cas)
Dichotomie
donc O(1).
Si n = 2p alors
+ 1} = · · · = C20 +p = Θ(log2 n)
C2p = C2p−1 + 1 = C2p−2 + 1| {z
|{z}
2 cte
Dichotomie
donc O(1).
Si n = 2p alors
+ 1} = · · · = C20 +p = Θ(log2 n)
C2p = C2p−1 + 1 = C2p−2 + 1| {z
|{z}
2 cte
Pour n quelconque, 2blog2 nc

≤n< 2blog2 nc+1 .
Comme la complexité
est croissante avec la taille du tableau
Cn ≤ C2blog2 nc+1 = O(blog2 nc + 1). Il vient Cn = O(log2 n).
Dichotomie
donc O(1).
Si n = 2p alors
+ 1} = · · · = C20 +p = Θ(log2 n)
C2p = C2p−1 + 1 = C2p−2 + 1| {z
|{z}
2 cte
Pour n quelconque, 2blog2 nc

≤n< 2blog2 nc+1 .
Comme la complexité
est croissante avec la taille du tableau
Cn ≤ C2blog2 nc+1 = O(blog2 nc + 1). Il vient Cn = O(log2 n).
Idem minoration :
Cn ≥ C2blog2 nc = Ω(blog2 nc + 1) : Conclusion, Cn = Θ(log2 n)
Exponentiation rapide
1 let rec puissance_rapide x n = match n with

2 | 0 -> 1
3 | n when n mod 2 = 0 -> puissance_rapide ( x * x ) ( n /2)
4 | _ -> x * puissance_rapide x (n -1) ;;
Principe x 2k = (x 2 )k et x 2k+1 = x · x 2k

2 | 0 -> 1
Complexité en nombre de multiplications

2 | 0 -> 1
Lorsque n est paire Cn = Cn/2 + 1 = Cb n2 c + 1.

2 | 0 -> 1
Si n est impaire (et > 1), Cn = 1 + Cn−1 = 1 + C(n−1)/2 + 1 = Cb n2 c + 2.

2 | 0 -> 1
Donc récurrence de la forme Cn = Cb n2 c + O(1). On étudie toujours la
forme la plus simple Cn = Cb n2 c + 1. On a vu que Cn = O(log2 n)

2 | 0 -> 1
Donc récurrence de la forme Cn = Cb n2 c + O(1). On étudie toujours la
forme la plus simple Cn = Cb n2 c + 1. On a vu que Cn = O(log2 n)
Il est pertinent ici d’exprimer la complexité en fonction du nombre de
bits de n : il vaut blog2 nc + 1 = Θ(log2 n). Donc complexité linéaire
en le nombre de bits de l’exposant.
Exemples de complexités de fonctions récursives Tri fusion
1 Introduction
Présentation

Tri fusion
Tri fusion
Pour raison de commodité, on étudie la complexité d’une version non

récursive terminale du tri fusion. On donne néanmoins une version
récursive terminale après cette étude.
Tri fusion
Division
On veut trier une liste. On sépare l’entrée en deux listes/deux tableaux

(approximativement) de même longueur, qu’on trie séparément, puis on
fusionne les deux résultats en comparant à chaque fois les plus petits
éléments.
1 let rec divise l = match l with
2 | [] -> ([] ,[])
3 | [ e ] -> ([ e ] ,[])
4 | a :: b :: r -> let ( m1 , m2 ) = divise r in ( a :: m1 , b :: m2 ) ;;
Complexité remporelle de la forme Cn = Cn−2 + 1. Ainsi, pour

n = 2k :
C2k = C2k−2 + 1 = C2k−4 + 1 + 1 = · · · = C0 + k
On trouve de même C2k+1 = C1 + k pour n = 2k + 1.
Tri fusion
Division
On veut trier une liste. On sépare l’entrée en deux listes/deux tableaux

(approximativement) de même longueur, qu’on trie séparément, puis on
fusionne les deux résultats en comparant à chaque fois les plus petits
éléments.
1 let rec divise l = match l with
2 | [] -> ([] ,[])
3 | [ e ] -> ([ e ] ,[])
4 | a :: b :: r -> let ( m1 , m2 ) = divise r in ( a :: m1 , b :: m2 ) ;;
Complexité remporelle de la forme Cn = Cn−2 + 1. Ainsi, pour

n = 2k :
C2k = C2k−2 + 1 = C2k−4 + 1 + 1 = · · · = C0 + k
On trouve de même C2k+1 = C1 + k pour n = 2k + 1.
n
Comme dans les 2 hypothèses de parité et d’imparité, k = b c, on
2
obtient Cn = Θ(n)
Tri fusion
fusion
On fusionne deux listes triées (par ordre croissant) en ajoutant

prioritairement le plus petit élément des deux listes.
1 (* pour une recursion terminale voir plus loin *)
2 let rec fusion l1 l2 = match ( l1 , l2 ) with
3 | (l ,[]) | ([] , l ) -> l
4 | ( a :: r , b :: s ) -> if a <= b
5 then a ::( fusion r l2 )
6 else b ::( fusion l1 s ) ;;
Hors appels récursifs internes, les opérations sont en O(1) et en

nombre borné.
Tri fusion
fusion

3 | (l ,[]) | ([] , l ) -> l
4 | ( a :: r , b :: s ) -> if a <= b

nombre borné.
La complexité dépend de la façon dont sont réparties les données dans
les listes. Meilleur cas en O(min(|`1 | , |`2 |)) : lorsque tous les éléments
de la liste la plus courte sont plus petits que ceux de la plus longue.
Tri fusion
fusion

3 | (l ,[]) | ([] , l ) -> l
4 | ( a :: r , b :: s ) -> if a <= b

nombre borné.
La complexité dépend de la façon dont sont réparties les données dans
les listes. Meilleur cas en O(min(|`1 | , |`2 |)) : lorsque tous les éléments
de la liste la plus courte sont plus petits que ceux de la plus longue.
Pour éviter un raisonnement qui tiendrait compte de la répartition des
données, on peut étudier la complexité d’une fonction manifestement
plus coûteuse : fusion couteuse du transparent suivant.
Tri fusion
fusion
La fonction suivante réalise aussi la fusion. Elle est plus coûteuse que
la précédente mais plus facile à étudier :
1 let rec fusion_couteuse l1 l2 = match ( l1 , l2 ) with
2 | ([] ,[]) -> []
3 | ( a :: r ,[]) | ([] , a :: r ) -> a ::( fusion_couteuse [] r )
4 | ( a :: r , b :: s ) -> if a <= b
5 then a ::( fusion_couteuse r l2 )
6 else b ::( fusion_couteuse l1 s ) ;;
Tri fusion
fusion
2 | ([] ,[]) -> []
4 | ( a :: r , b :: s ) -> if a <= b
La complexité dépend seulement de la somme des tailles des listes. En

notant n, m les tailles de l1,l2 on obtient la relation suivante
C (n + m) = C (n + m − 1) + O(1) et C (0, 0) = 1.
Tri fusion
fusion
2 | ([] ,[]) -> []
4 | ( a :: r , b :: s ) -> if a <= b

C (n + m) = C (n + m − 1) + O(1) et C (0, 0) = 1.
On étudie donc C (n + m) = C (n + m − 1) + 1. Il s’agit d’une suite
arithmétique. On a donc C (n + m) = O(n + m)
Tri fusion
fusion
2 | ([] ,[]) -> []
4 | ( a :: r , b :: s ) -> if a <= b

C (n + m) = C (n + m − 1) + O(1) et C (0, 0) = 1.
On étudie donc C (n + m) = C (n + m − 1) + 1. Il s’agit d’une suite
arithmétique. On a donc C (n + m) = O(n + m)
Donc la complexité de fusion , toujours meilleure est aussi en
O(n + m)
Tri fusion
Tri

2 let rec tri_fusion l = match l with
3 | [] -> []
4 | [ e ] -> [ e ]
5 | l -> let ( m1 , m2 ) = divise l in
6 fusion ( tri_fusion m1 ) ( tri_fusion m2 ) ;;
Tri fusion
Complexité du tri
On note n la longueur de l . La division est en Θ(n). La fusion

s’applique aux deuxx moitiés triées ; elle a ici un coût en Θ(n) (même
au mieux).
Tri fusion
Complexité du tri

au mieux).
La complexité obéit à une relation diviser-pour-régner de la forme
Cn = Cb n2 c + Cd n2 e + Θ(n) ; simplifié en Cn = Cb n2 c + Cd n2 e + n
Tri fusion
Complexité du tri

au mieux).
Si n = 2k alors b n2 c = d n2 e (et k = log2 n) :
C2k = 2k +2C2k−1 = 2·2k +22 C2k−2 = · · · = k2k +2k ·C2k−k = Θ(n log2 n)
Tri fusion
Complexité du tri

au mieux).
Si n = 2k alors b n2 c = d n2 e (et k = log2 n) :
C2k = 2k +2C2k−1 = 2·2k +22 C2k−2 = · · · = k2k +2k ·C2k−k = Θ(n log2 n)
En général, 2blog2 nc ≤ n < 2blog2 nc+1 . Comme la complexité est ↑ :
 
O(log2 n)
z }| {
Cn ≤ C2blog2 nc+1 = O (blog2 nc + 1) |2blog{z2 nc+1
} = O(n log n)
 
O(n)
Idem pour une minoration. Cn = Θ(n log2 n)

Tri fusion en récursion terminale
On donne ici une version totalement récursive terminale du tri fusion (on
se souvient que List.rev est aussi en récursion terminale).
1 (* vide l alternativement dans l1 et l2 : *)
2 let rec split l l1 l2 = match l with
3 | [] -> l1 , l2
4 | x :: t -> split t l2 ( x :: l1 ) ;;
5
6 let rec merge acc l1 l2 = match l1 , l2 with
7 | [] , l ’ | l ’ , [] -> ( List . rev acc ) @ l ’
8 | x1 :: t1 , x2 :: t2 -> if x1 <= x2
9 then merge ( x1 :: acc ) t1 l2 else merge ( x2 :: acc ) l1 t2 ;;
0
1 let rec sort l = match l with
2 | [] | [ _ ] -> l
3 | _ -> let l1 , l2 = split l [] [] in
4 merge [] ( sort l1 ) ( sort l2 ) ;;
Tri fusion impératif
Vocabulaire : le tri d’un tableau est dit en place si l’algorithme

travaille directement sur le tableau en entrée et n’utilise pas de
tableau auxiliaire.
Un tri est stable s’il conserve les positions relatives des éléments de
même valeur.

tableau auxiliaire.
même valeur.
Il existe une version du tri fusion pour les tableaux.
Une version délicate (mais possible) existe pour un maintien en place
mais non stable.

tableau auxiliaire.
même valeur.
mais non stable.
Le tri fusion est en O(n log n) au pire, au meilleur et en moyenne.

tableau auxiliaire.
même valeur.
mais non stable.
Le tri fusion est en O(n log n) au pire, au meilleur et en moyenne.
On ne peut pas faire mieux en moyenne (voir cours sur les arbres)
pour un tri par comparaison (algorithmes de tri procédant par
comparaisons successives entre éléments).

Complexite Slides PDF

Transféré par

Droits d'auteur :

Formats disponibles

Complexite Slides PDF

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

Complexite Slides PDF

Transféré par

Droits d'auteur :

Formats disponibles

Complexité

3 Exemples de complexités de fonctions récursives

3 Exemples de complexités de fonctions récursives

1  Option informatique MPSI, MP/MP* , Roger Mansuy, paru chez

1  Option informatique MPSI, MP/MP* , Roger Mansuy, paru chez

1  Option informatique MPSI, MP/MP* , Roger Mansuy, paru chez

L’analyse de la complexité d’un algorithme consiste en l’étude formelle de

L’analyse de la complexité d’un algorithme consiste en l’étude formelle de

Soit f un programme prenant en paramètre une donnée d

Soit f un programme prenant en paramètre une donnée d

Soit f un programme prenant en paramètre une donnée d

Pour une donnée de taille n :

La plupart du temps, on se contente de donner une majoration  à

3 Exemples de complexités de fonctions récursives

3 Exemples de complexités de fonctions récursives

Il y en a d’autres que nous dévoilerons au fur et à mesure.

Il y en a d’autres que nous dévoilerons au fur et à mesure.

On cherche les diviseurs d’un entier n :

On cherche les diviseurs d’un entier n :

Ce programme effectue exactement n − 2 calculs de restes de

On cherche les diviseurs d’un entier n :

Ce programme effectue exactement n − 2 calculs de restes de

Exemple introductif (2)

Exemple introductif (2)

Exemple introductif (2)

Exemple introductif (2)

Exemple introductif (2)

Déterminer le temps d’exécution en fonction de la taille du problème.

Déterminer le temps d’exécution en fonction de la taille du problème.

Déterminer le temps d’exécution en fonction de la taille du problème.

Déterminer le temps d’exécution en fonction de la taille du problème.

Déterminer le temps d’exécution en fonction de la taille du problème.

Déterminer le temps d’exécution en fonction de la taille du problème.

Déterminer le temps d’exécution en fonction de la taille du problème.

Déterminer le temps d’exécution en fonction de la taille du problème.

Modèle de complexité temporelle impérative

La complexité d’un algorithme est une fonction C définie inductivement.

Modèle de complexité temporelle impérative

La complexité d’un algorithme est une fonction C définie inductivement.

Modèle de complexité temporelle impérative

La complexité d’un algorithme est une fonction C définie inductivement.

Modèle de complexité temporelle impérative

La complexité d’un algorithme est une fonction C définie inductivement.

Modèle pour la complexité temporelle

Modèle pour la complexité temporelle

Modèle pour la complexité temporelle

Complexité temporelle (cas fonctionnel)

On essaye d’établir une relation de récurrence entre C (n) (la

Complexité temporelle (cas fonctionnel)

On essaye d’établir une relation de récurrence entre C (n) (la

Complexité temporelle (cas fonctionnel)

On essaye d’établir une relation de récurrence entre C (n) (la

Complexité temporelle (cas fonctionnel)

On essaye d’établir une relation de récurrence entre C (n) (la

Complexité temporelle (cas fonctionnel)

On essaye d’établir une relation de récurrence entre C (n) (la

C (n) = C (n −1)+1 = (C (n −2)+1)+1 = · · · = C (1) +n −1 = O(n)

Complexité temporelle (cas fonctionnel)

Complexité temporelle (cas fonctionnel)

1 Option informatique MPSI, MP/MP* , Roger Mansuy, paru chez

1 Option informatique MPSI, MP/MP* , Roger Mansuy, paru chez

1 Option informatique MPSI, MP/MP* , Roger Mansuy, paru chez

La plupart du temps, on se contente de donner une majoration à