COMPLEXIT DES ALGORITHMES

0
0 INTRODUCTIONS, RAPPELS
Le principe est davoir une mesure pour valuer les performances dun algorithme (temps dexcution ou espace
mmoire).
Le but est de comparer les algorithmes rsolvant un mme problme.
La complexit en espace correspond lespace mmoire (nombre doctets) ncessaire lexcution sur une
donne de taille N.
La complexit en temps correspond au temps dexcution (nombre doprations lmentaires) de lalgorithme
sur une donne de taille N.

0.1 EXEMPLES
0.1.1 Premier exemple
Somme des entiers de 1 n :
0.1.1.1 Solution 1
Som0
Pour i de 1 n faire somsom+i
Cet algorithme, en terme :
- despace, utilise 3 entiers (cods par exemple sur 4 octets) donc 12 octets au total (quelle que soit la
valeur de n)
- de temps :
o Affectations : 2n+1 (initialisation de la somme)
o Arithmtique : n additions + n affectations ii+1
o Comparaisons : n
Il y a donc 5n+1 oprations. Cest donc proportionnel n, cest dire linaire.
0.1.1.2 Solution 2
Somn*(n+1)/2
Cet algorithme, en terme :
- Despace : 2 entiers, soit 8 octets
- De temps : 4 oprations lmentaires : la complexit est constante, elle est indpendante de n.
0.1.1.3 Conclusion
La deuxime solution est la plus adapte.

0.1.2 Deuxime exemple

Un tableau de n entiers strictement positifs et trouver une valeur infrieure *Valeurs
0.1.2.1 Solution 1
Faire le calcul de la somme des valeurs, puis rechercher une valeur infrieure *Valeurs
La complexit en temps est alors proportionnelle n.
0.1.2.2 Solution 2
Le minimum des deux premiers entiers, sauf si les deux entiers sont gaux ou sil ny a quun seul entier.

0.2 CE QUIL FAUT RETENIR

A un problme donn, il existe plusieurs solutions algorithmiques. Il faut les comparer par rapport leurs
complexits. Il faut sassurer que lalgorithme propos est le meilleur possible pour le problme considr. En
ralit, chaque problme a sa propre complexit (connue ou non). Ds quun algorithme la mme complexit, il
est optimal.
Plus formellement : soient A un algorithme, d la donne de cet algorithme, D n lensemble de toutes les donnes
possibles, de taille n :
Cot espace (A, d) (en octets) et cot temps (A, d) (en nombre doprations lmentaires) de lexcution de A sur d.

1
On sintresse trois types de cot :
- Le cot minimum : il correspond au meilleur des cas : Minn(A) = mindDn {cot (A, d)}
- Le cot maximum : il correspond au pire des cas : Maxn(A)= maxdDn {cot (A, d)}
- Le cot moyen : Moyn(A)=dDn P(d)*{cot (A, d)}
Ou P(d) est la probabilit dapparition de la donne d. Si les donnes sont quiprobables alors P(d)=1/
(Card[Dn])

1 EXPRESSION DE LA COMPLEXIT
Supposons quun algorithme ncessite 3n+7 oprations lmentaires pour une donne de taille n. Ce qui est
important de retenir cest que dans ce cas, la complexit est proportionnelle n (de manire approche).
En effet, si la taille est n, alors le temps est t=3n+7. Si la taille est 2n alors le temps est t=6n+7=2t
La complexit va donc mesurer lvolution du cot en fonction de lvolution de la taille des donnes.

1.1 NOTATIONS
Soient deux fonctions f et g NN
On dit que f=O(g) f est domine par g A partir dun rang n0 f(n) Cste.g(n)
On dit que f=(g) f et g sont asymptotiquement quivalentes f=O(g) et g=O(f)
En pratique, on exprime donc les complexits sous la forme (g) avec g trs simple.

1.2 EXEMPLES
(1) : complexit constante (exemple : la somme des entiers de 1 n)
(log(n)) : logarithmique (exemple : recherche dichotomique)
(n) : complexit linaire (exemple : recherche squentielle)
(n*log(n)) : complexit sub-quadratique (exemple : tri rapide)
(n) : complexit quadratique (exemple : tris simples)
(nk) : complexit polynomiale
(2n) : complexit exponentielle (exemple : Tours de Hanoi)
On fera donc par exemple : 3n3+6n+17n+3 (n3)
Influence de la complexit sur lexcution :
Prenons lexemple dune machine qui fait une opration lmentaire en 1s (soit 106 oprations par seconde)
Taille de n \ Complexit 1 log(n) n n*log(n) n n3 2n
100 1s 7 s 100 s 0.7 ms 10 ms 1s 4.1016 annes
10000 1 s 14 s 10 ms 0.14 s 1,5 min 11.5 jours infini
106 1 s 20 s 1s 20s 11.5 jours 32.106 annes infini

2 DTERMINATION DE LA COMPLEXIT
2.1 DANS LESPACE
Cest en gnral facile, surtout pour les donnes statiques : la taille est connue en fonction du type. Pour les
ordres de grandeurs, seuls les tableaux comptent. La seule difficult apparat dans les allocations dynamiques
(mmoire demande en cours dexcution) ou dans les algorithmes rcursifs (il faut compter le nombre dappels
pour avoir une ide de la taille.

2.2 DANS LE TEMPS

Enchanements squentiels : Lordre de grandeur de la squence correspond la valeur maximale.
Squences dactions lmentaires : (1)
Sil y a un appel de fonction, il faut inclure la complexit de cette fonction dans la complexit de la
squence.

2
 Alternative (Sialorssinon) : On prend toujours la complexit maximale. Sinon on peut aussi faire
une complexit moyenne mais il faut avoir des informations sur le rsultat moyen de la condition.
Boucles : Complexit = (Complexit du corps de boucle) x (Nombre de tours).
Algorithme rcursif : Complexit = (Complexit de la fonction) x (nombre dappels).

2.3 REMARQUES
Pour un algorithme, on considre uniquement les oprations fondamentales, cest dire celles qui ont de
linfluence sur la complexit :
Pour un algorithme de recherche, il sagit de comparer deux objets : proportionnel la taille de lobjet.
Pour un algorithme de tri : comparaisons + transferts
Pour un algorithme de fichiers : accs aux disques
Attention aux grands nombres : un petit nombre est un type prdfini de taille connue ou doprations
lmentaires.

2.4 EXEMPLES : LES ALGORITHMES DE TRIS

Les algorithmes de tris ont deux types doprations fondamentales : les comparaisons et les transferts.
On peut distinguer deux types de tris :
- Les tris internes : en mmoire centrale :
o Tri dun tableau
o Tri dun tableau sur lui-mme
- Les tris externes : tri de fichiers

2.4.1 Les tris simples

Ils sont faciles mettre en uvre mais leur complexit est mauvaise ((N)) et ne sont utilisables que sil y a peu
de valeurs trier (104 valeurs).
2.4.1.1 La slection ordinaire
Ide : on cherche le minimum et on le met la case 0, puis on cherche le minimum suivant que lon met la case
suivante et ainsi de suite. Cela correspond lalgorithme suivant :

Action TriSelection (ES : T :Ttableau, E : N : entier)

Var, I, pos, posmin, : entiers
Dbut
Pour I de 0 N-2 faire
{recherche de la position du minimum entre I et N-1}
posminT[I]
Pour pos de I+1 N-1 faire
Si T[pos]<T[posmin] alors posminpos {comparaison}
Echanger (T, I, posmin) {transfert}
Fin

La fait que tout le tableau soit en entre implique quil y a autant de transferts que de comparaisons. On peut la
trouver ainsi :
Nombre de transferts : 3 par boucle I, faite N-1 fois donc : 3N-3 soit une complexit (N). cest donc
optimal.
Nombre de comparaisons : 1 par boucle pos, et il y a (N-1)+(N-2)++1=N(N-1)/2 boucles. La
complexit est donc de (N), ce qui est trs mauvais.
2.4.1.2 Le tri Bulle
On compare la premire case avec la seconde. Si la case 1 est plus petite que la case 2, on change de place. Puis
on compare la case 2 et la case 3 et ainsi de suite.

Action Tri Bulle (ES : T : Ttableau ; E : N : entier)

Var : I, J, entiers fini : boolen
Dbut
I0
Rpter :
Finivrai

3
 Pour J de n-1 I+1 par pas de 1 faire
Si T[j]<T[j-1] alors Echanger (T, J, J-1) et fini faux.
II+1
Jusqu' (fini=vrai ou I=N-1)
Fin

Complexit de cet algorithme :

Dans le meilleur des cas (tableau dj tri) : on a N-1 comparaisons (N) et 0 transferts (1)
Dans le pire des cas (tableau tri lenvers) on obtient N(N-1)/2 nombres de transferts et N(N-1)/2
nombres de comparaisons. On a alors une complexit de (N) ; ce qui est trs mauvais.
En moyenne : Le calcul dune moyenne est trop compliqu. On admettra que la complexit moyenne est
de (N).
2.4.1.3 Insertion squentielle
Il sagit de lalgorithme suivant :

Action tri_insertion (.)

Var : pos, I : entiers
Element : Tinformations
Trouv : boolen
Dbut :
Pour I de 1 N-1 faire :
{on cherche la position de T[i] entre 0 et i-1 de droite a gauche en dcalant les plus grands}
ElementT[i]
Posi-1,
trouvfalse
tant que (non trouv et pos0) faire
si T[pos]>Element alors T[pos+1]T[pos] et pospos-1
sinon trouvvrai
{on range llment}
T[pos+1]Element {transfert}
Fin
Fin

Complexit de cet algorithme :

Dans le meilleur des cas (tableau tri) la complexit du nombre de comparaisons et de transferts est de
(N)
Dans le pire des cas : (N)
En moyenne : (N)

Remarques :
Il existe une amlioration cet algorithme : en faisant une recherche de la position dinsertion par
dichotomie. La complexit du nombre de comparaisons est alors (NlogN), ce qui est optimal.
Lorsquon tri de gros objets, on ne peut pas viter de les comparer mais on peut viter de les dplacer en
crant un deuxime tableau contenant les indices de lordre du tri du premier tableau.

2.4.2 Les tris rapides

Les tris rapides ou Quick sort. Lide est la suivante
P P >P
P est sa place. P est un pivot
- On choisit une valeur
- Rorganiser le tableau en fonction de ce pivot
- Rcursivement, on tri les 2 cts.
Remarque : On tri des parties de tableau, il faut donc indiquer le dbut et la fin de la portion a traiter : les
paramtres seront donc T, dbut, fin.
Action Tri Rapide (ES T : Ttableau, E : dbut, fin :entiers)
Var : pospivot : entier
Dbut

4
 Si fin > dbut {il faut au moins deux cases !}
Rarranger (T, dbut, fin, pospivot)
Tri Rapide (T, dbut, pospivot-1)
Tri Rapide (T, pospivot+1, fin
Fin
Pour trier le tableau entier il suffit dappeler laction Tri Rapide (T, 0, n-1)

Quen est il de laction rarranger ? Etudions tout dabord son principe.

Comment fait-on le choix de la valeur pivot ? Au hasard, on peut prendre T[dbut] (premire case de la portion)
par exemple.
25 8 43 15 52 63 9 81 on sauve T[dbut] dans une variable temporaire et on cherche plus petit que
9 8 43 15 52 63 43 81 T[dbut] depuis la droite. On peut le copier dans T[dbut] car la valeur a t
9 8 43 15 52 63 43 81 sauvegarde. Puis on cherche plus grand depuis la gauche et on le met dans
9 8 15 25 52 63 43 81 lancienne case du premier plus petit trouv. Et ainsi de suite. A la fin du
traitement on a tous les plus petits dun cot, et les plus grand de lautre. Il ne
reste plus qua rinsrer la valeur temporaire sa place.

Action Rarranger (ES : T : Ttableau, E : dbut, fin : entiers S : pospivot : entier)

Var : pivot : Tinfo, G, D : entiers {indices pour la recherche}
Trouv, cherchedroite : boolen {Si vrai on cherche droite sinon, on cherche gauche}
Dbut
Pivot T[dbut]
G dbut
D fin
cherchedroitevrai
Tant que D>G faire
Si cherchedroite alors
Trouvfaux
Tant que (D>G ET non trouv) faire
Si T[d]pivot alors trouvvrai
Sinon DD-1
Si trouv alors
T[G]T[D]
GG+1
Sinon
Trouvfaux
Tant que (G<D ET non trouv) faire
Si T[G]>pivot alors trouvfaux
Sinon GG+1
Si trouv alors
T[D]T[G]
DD-1
cherchedroite ! cherchedroite
T[D]pivot
pospivotD
Fin

Complexit de cet algorithme

En moyenne, cet algorithme est optimal : (NlogN)
Au maximum (N)

Remarque :
Pour trouver mieux que le tri Quick Sort, il faudrait un programme qui ait une complexit moyenne de NlogN et
une complexit maximale de NlogN. Cet algorithme existe : cest le tri par pas.

2.4.3 Les tris externes

Ces tris peuvent tre adapts aux tris internes mais en utilisant 2 tableaux.

5
2.4.3.1 Tri balanc par monotonies de longueur 2n.
Soit le fichier F1 : 8 15 3 9 25 32 22 6
- tape 1 : clater le fichier F1 sur F3 et F4 qui seront de mme taille. On clate alternativement (cest
dire que lon distribue alternativement les donnes de F1 dans F3 et F4) on obtient les fichiers :
F3 : 8 3 25 22
F4 : 15 9 32 6
On a alors construit des monotonies de longueur 1.
- tape 2 : on fusionne les monotonies de longueur pour avoir des monotonies de longueur 2, clates sur
F1 et F2. On obtient donc les fichiers suivants :
F1 : 8 15 25 32
F2 : 3 9 6 22
- tape 3 : On prend les monotonies de longueur 2 pour avoir des monotonies de longueur 4.
F3 : 3 8 9 15
F4 : 6 22 25 32
- tape 4 : on prend les monotonies de longueur 4 pour obtenir une monotonie de longueur 8, cest dire
le rsultat final.
F1 : 3 6 8 9 15 22 25 32

Complexit de cet algorithme :

Le nombre dtape est logN et le cot dune tape est de N. Donc, dans tous les cas, on a une complexit
(NlogN).

Remarque :
Pour transformer cet algorithme en interne, il ne faut pas oublier quil exige 4 fichiers. On peut les coder sous
forme de deux tableaux. En codant F1 sur le tableau 1, depuis le dbut et F2 sur le tableau 1 depuis la fin (on
code ainsi deux fichiers par tableau. Cest possible car le contenu du tableau ne varie pas.)
2.4.3.2 Idem mais
On peut appliquer le mme modle, mais en prenant les monotonies naturelles du fichier F1 initial :
F1 : 8 15 3 9 25 32 22 6
Lavantage par rapport lalgorithme prcdent, cest que si le tableau est dj tri, il neffectue pas les
oprations pour rien.
Avec un tel programme de tri, on obtient une complexit optimale en moyenne ((NlogN)), une complexit
optimale au maximum ((NlogN)) et optimale au minimum ((N))