Algo 4. Complexité

Chapitre 5:
Complexité
Algorithmique
2ème Année - Cycle Ingénieur

Algorithmique & Complexité BENAZZOUZ 2024-2025
• La théorie de la complexité algorithmique
s'intéresse à l'estimation de l'efficacité des
algorithmes (en terme de mémoire et de temps
d‘exécution).
• Question : entre différents algorithmes réalisant

une même tâche, quel est le plus rapide et dans
quelles conditions ?
– exemple course de voiture !
2
Pour qu'une analyse ne dépende pas de la vitesse
d'exécution de la machine ni de la qualité du code
produit par le compilateur, il faut utiliser comme unité
de comparaison des « opérations élémentaires » en
fonction de la taille des données en entrée.
Quelques exemples d'opérations élémentaires (atomiques):

– accès à une cellule mémoire ou affectation ;
– comparaison de valeurs ;
– opérations arithmétiques (sur valeurs à codage de taille fixe) ;
– opérations sur des pointeurs.
3
Exemple1 :
int Somme ( int N )

{
int acc = 0 , nb = 1 ;
Que fait cet
while ( nb < = N )
{
algorithme ?
acc = acc + nb;
nb = nb + 1 ;
}
return acc ;
} 4
Exemple1 :
int Somme ( int N ) Cet algorithme demande:
{ – 2 affectations,
– N+1 comparaisons,
int acc = 0 , nb = 1 ; – N sommes et affectations,
while ( nb < = N ) – N sommes et affectations,
{ ce qui fait au total 5N+3
acc = acc + nb; opérations élémentaires.
nb = nb + 1 ; Ce qui nous intéresse c'est un

ordre de grandeur (cout exact,
}
valeur asymptotique), donc : la
return acc ; complexité de cet algo est de
l'ordre de N, ou encore linéaire
}
en N.
5
Exemple2 :
Si on utilise les propriétés des séries numériques :
int Somme ( int N ) Cet algorithme demande : ?
{ • 2 affectations,
• 3 opérations arithmétiques
int acc = 0;
Même problème résolu en

acc = (N*(N+1))/2 ;
temps constant (indépendant
return acc ; des données) !
} 6
On distingue :
– la complexité dans le pire des cas, ou
complexité dans le cas le plus défavorable,
mesure la complexité (par exemple en temps
ou en espace) d'un algorithme dans le pire
des cas d'exécution possibles.
– la complexité dans le meilleur des cas
correspond à la complexité (par exemple en
temps) d'un algorithme dans le cas
d'exécution le plus favorable possible.
7
Type de complexité algorithmique :
On considère désormais un algorithme dont le temps maximal

d’exécution pour une donnée de taille n en entrée est noté T(n).
Chercher la complexité au pire – dans la situation la plus

défavorable – c’est exactement exprimer T(n) en général en
notation O (La notation grand O indique « l’ordre de grandeur »
des fonctions.)
· T(n) = O(1), temps constant : temps d’exécution indépendant

de la taille des données à traiter(le cas de notre exemple2).
8
· T(n) = O(log(n)), temps logarithmique (algo sous linéaire) : on

rencontre généralement une telle complexité lorsque
l’algorithme casse un gros problème en plusieurs petits, de sorte
que la résolution d’un seul de ces problèmes conduit à la
solution du problème initial.
Exemple : cas de la recherche d'un élément dans un

ensemble ordonné fini de cardinal n.
9
· T(n) = O(n), temps linéaire : cette complexité est généralement
obtenue lorsqu’un travail en temps constant est effectué sur chaque
donnée en entrée.
Exemple : évaluation de la valeur d'une expression composée de
n symboles.
· T(n) = O(n.log(n)) (quasi- linéaire), l’algorithme scinde le

problème en plusieurs sous problèmes plus petits qui sont résolus de
manière indépendante. La résolution de l’ensemble de ces
problèmes plus petits apporte la solution du problème initial.
Exemple : les algorithmes optimaux de tri(heapsort).
10
· T(n) = O(n²), temps quadratique : apparaît notamment lorsque
l’algorithme envisage toutes les paires de données parmi les n
entrées.
Exemple : deux boucles imbriquées, tri naif
· T(n) = O(n3) temps cubique.
Exemple : multiplication des matrices, parcours dans les
graphes
· T(n) = O(2n), temps exponentiel : souvent le résultat de recherche
brutale d’une solution.
· T(n) = O(n!) : complexité factorielle.
11
Graphe représentant la différence entre leurs
croissances respectives lorsque n tend vers l'infini.
12
Nomenclature des classes de complexité
L'idée de base est donc qu'un algorithme en O(na) est « meilleur » qu'un
algorithme en O(nb), si a < b.
est-ce qu'en pratique 100 * n2 est « meilleur » que 5 * n3 ?

13
Exemples : (1)
Test de primalité ?
• Pour tester si N est premier ?
• On vérifie s’il est divisible par l’un des entiers compris au
sens large entre 2 et N-1 (ou encore mieux 𝑛 ).
Si la réponse est négative, alors N est premier,
sinon il est composé.
complexité racinaire :
14
Exemples : (2)
x=n;
while ( x > 0 )
{ O(n)
x=x–1;
}
15
Exemples : (3)
x=n;
while ( x > 0 )
{ O(log2(n))
x=x/2;
}
16
Exemples : (4)
x=n;
while ( x > 0 ) { 2
O(n )
y=n;
while ( y > 0 ) {
y=y–1;
}
x=x–1;
}
17
Exemples : (5)
x=n;
while ( x > 0 ) {
y=n;
while ( y > 0 ) { O(n.log2(n))
y=y/2;
}
x=x–1;
}
18
Exemples : (6)
x=n;
while ( x > 0 ) {
y=n;
while ( y > 0 ) { O(n.log2(n))
y=y–1;
}
x=x/2;
}
19
Exemples : (7)
O(log2(n))
Iterative-Binary-Search(A, v, low, high)
while (low <= high)
mid=[(low + high)/2]
if v = A[mid] return mid
if v > A[mid]
low = mid + l
else high= mid - 1
return -1
20
Exemples : (8)
x=n;
while ( x > 0 ) {
y=x;
while ( y > 0 ) { O(???)
y=y–1;
}
x=x/2;
}
21
Exemples : (8)
x=n;
while ( x > 0 ) {
y=x;
Une série géométrique
while ( y > 0 ) { infinie converge vers 2.
y=y–1;
} T(n)= n⋅2=2n
x=x/2;
} O(n)
22

Algo 4. Complexité

Transféré par

Droits d'auteur :

Formats disponibles

Algo 4. Complexité

Transféré par

Informations du document

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

Algo 4. Complexité

Transféré par

Droits d'auteur :

Formats disponibles

Chapitre 5:

2ème Année - Cycle Ingénieur

• Question : entre différents algorithmes réalisant

Quelques exemples d'opérations élémentaires (atomiques):

int Somme ( int N )

nb = nb + 1 ; Ce qui nous intéresse c'est un

Si on utilise les propriétés des séries numériques :

int Somme ( int N ) Cet algorithme demande : ?

Même problème résolu en

return acc ; des données) !

On considère désormais un algorithme dont le temps maximal

Chercher la complexité au pire – dans la situation la plus

· T(n) = O(1), temps constant : temps d’exécution indépendant

· T(n) = O(log(n)), temps logarithmique (algo sous linéaire) : on

Exemple : cas de la recherche d'un élément dans un

· T(n) = O(n.log(n)) (quasi- linéaire), l’algorithme scinde le

est-ce qu'en pratique 100 * n2 est « meilleur » que 5 * n3 ?

Vous aimerez peut-être aussi