Complexité

04/11/2008
Déroulement
Algorithmes et
structures de données
(avancées)
Cours 7
Patrick Reuter
• CM mardi de 8h à 9h (salle 33)
• TD
- Groupe 1 : mardi, 13h30 – 15h00 (salle 51D)
- Groupe 2 : mardi, 15h15 – 16h45 (salle 51D)
(en alternance: salle TD et salle machine)
http://www.labri.fr/~preuter/asd2008
(rendre la feuille à la prochaine séance)
Complexité
• TP 4
• Complexité
• Fonctions
Exigences à un programme
• Lisibilité
• Extensibilité
• Portabilité
• Réutilisable
• Fiabilité
• Efficacité (faible complexité)
Complexité
• Quel est le temps d’éxécution du programme?
Æ Complexité temporelle
De combien de mémoire le programme a-t-il besoin?
Æ Complexité de mémoire (ou Complexité spatiale)
Comment déterminer ces complexités ?
Æ méthode empirique
Æ méthode mathématique
Complexité
Méthode mathématique
• Théorie de la complexité
– Temporelle
– Spatiale
• Basée sur une machine abstraite
– Random-access memory (RAM)
– Instructions de base (affectation, boucle, appel de
fonctions …)
• longueur des données d’entrée n
• Ce temps est une fonction T(n) où n est la
longueur des données d’entrée.
1
04/11/2008
Théorie de la complexité –
Changement de la fonction
Complexité : T(n) – Exemple 1
2ème solution
changer la fonction
• Calculer
• T1(n) = log2n
somme =0;
i=1;
logarithmique
• T2(n) = n
TANT QUE i <= n FAIRE
DEBUT
somme = somme + i;
i=i+1;
FIN
linéaire
• T3(n) = n log2 n
Quasi-linéaire
• T4(n) = n2
quadratique
Affectations :
Comparaisons :
2 +2*n
n+1
Æ T(n) = 3n+3
• T5(n) = n3
cubique
• T6(n) = 2n
exponentiel
Théorie de la complexité
Classes de Grand-O
•
•
O(1)
O(log n)
complexité constante
complexité logarithmique
•
O(n)
complexité linéaire
•
O(n log n)
complexité quasi-linéaire
•
O(na)
–
–
•
complexité polynomiale
O(n2)
O(n3)
complexité quadratique
complexité cubique
O(an)
complexité exponentielle
O(log n) ⊂ O(n) ⊂ O(n log n) ⊂ O(n2) ⊂ O(n3) ⊂ O(2n)
Théorie de la complexité
•
Théorie de la complexité
•
•
Notation Grand-O
Exemple : (Exemple de T(n) = 3n+3)
Si
T(n) ≤ c n
pour une constante c et toutes les valeurs de n>n0, on dit
« T(n) est dans O(n) »
ou bien
T(n) ∈ O(n)
ou, par abus d’écriture,
T(n) = O(n)
Retour sur TP (1)
En général :
O(f) = {g | ∃c > 0 : ∃ n0 > 0 : ∀ n ≥ n0 : g(n) ≤ c f(n)}
Soit g une fonction non négative.
g est dans O(f) s’il existe deux constantes positives c et n0
telles que g ≤ cf(n) pour tout n > n0.
EXEMPLE : T(n) = 9n2 ∈ O(n2)
f = n2, g = 9n2
2
04/11/2008
Théorie de la complexité –
Changement de la fonction
• Question : est-ce qu'il faut inclure le tri dans
le chronométrage ?
--> en info, nous traitons souvent les données
en un préprocès, et après on en profite ….
2ème solution
changer la fonction
• T1(n) = log2n
logarithmique
• T2(n) = n
• 3 courbes
linéaire
• T3(n) = n log2 n
• O(n) recherche linéaire
• O(log n) recherche dichotomique
• O(n log n) tri
Quasi-linéaire
• T4(n) = n2
quadratique
• T5(n) = n3
cubique
• T6(n) = 2n
exponentiel
• Algorithme A1 en O(n)
• A2 : Exécuter 4 fois l’algorithme A1
• Quel est sa complexité ?
Elimination des constantes
• Algorithme A1 en O(n)
Si
T(n) ∈ O(kf(n))
où k > 0,
0 une constante
alors
T(n) ∈ O(f(n)).
• A3 : Exécuter 4n2 fois l’algorithme A1
• Quel est sa complexité ?
Les constantes sont ignorées!
3
04/11/2008
Règle des produits
Si
T1(n) ∈ O(f(n))
• Algorithme A1 en O(n)
• Algorithme A2 en O(n2)
et
T2(n) ∈ O(g(n))
• A4: Exécution successive de A1 et A2
alors
T1(n)T2(n) = O(f(n) g(n))
• Quel est sa complexité ?
Transitivité
Règle des sommes
Si
T1(n) ∈ O(f(n))
et
T2(n) ∈ O(g(n)),
alors
T1(n) + T2(n) ∈ O(max(f(n), g(n)))
Si
f(n) ∈ O(g(n))
et
g(n)) ∈ O(h(n)),
g(
( ( ))
alors
f(n) ∈ O(h(n)).
La notation Grand-O est transitive
La base du logarithme
• Algorithme A1 avec T1(n) = log2n
logan =
logbn
_____
logba
• Algorithme A2 avec T2(n) = log10n
• Quelle algorithme a la meilleure
complexité asymptotique ?
4
04/11/2008
La base du logarithme
logan =
logbn
_____
La base du logarithme
logan =
logba
logbn
_____
logba
< == >
< == >
logbn = logb a * loga n
logbn = logb a * loga n = c * loga n
La base du logarithme
logan =
logbn
_____
logba
< == >
logbn = logb a * loga n = c * loga n
Avec c = logb a
(ne dépend pas de n)
Æ
c peut être considéré
comme une constante
Fonctions
• Déclaration de fonctions
• Appel de fonction : Passage de paramètres
– Appel par valeur
– Appel
A
l par référence
éfé
• Ne pas confondre : afficher et retourner
(return !)
5
04/11/2008
Fonctions : mauvaise solution
FONCTION maximum(a, b)
DEBUT
SI a>b ALORS
afficher(a);
ffi h ( )
SINON
afficher(b);
Appel :
FIN
x = 3;
y = 5;
maximum(x,y);
Fonctions : bonne solution
FONCTION maximum(a, b)
DEBUT
SI a>b ALORS
return
t
a;
SINON
return b;
Appel :
FIN
x = 3;
y = 5;
afficher(maximum(x,y));
Fonctions : Passage de
paramètres
• Appel par valeur
• Appel par référence
Fonctions : bonne solution
FONCTION maximum(a, b)
DEBUT
SI a>b ALORS
return
t
a;
SINON
Appel :
return b;
x = 3;
FIN
y = 5;
z = maximum(x,y);
afficher(z);
Fonctions : bonne solution
En-tête de la fonction
FONCTION maximum(a, b)
DEBUT
SI a>b ALORS
Paramètres de la fonction
return
t
a;
SINON
Valeur de retour de la fonction
return b;
Corps de la fonction
FIN
Appel :
afficher(maximum(x,y));
Fonctions : Appel par valeur
FONCTION maximum(a, b)
DEBUT
SI a>b ALORS
return
t
a;
SINON
Appel :
return b;
x = 3;
FIN
y = 5;
z = maximum(x,y);
afficher(z);
6
04/11/2008
Fonctions : Appel par valeur :
Faire tourner
x
y
a
b
3
5
Fonctions : Appel par valeur
FONCTION maximum(a, b)
DEBUT
SI a<b ALORS
a=b;
b
return a; x
y
a
FIN
z
3
5
5
Appel :
x = 3;
y = 5;
z = maximum(x,y);
afficher(z);
b
z
3
5
3
5
Fonctions : Appel par valeur
FONCTION maximum(a, b)
DEBUT
Variables locales
SI a>b ALORS
c=a;
SINON
y a
x
b
c=b;
3
return c;
5
FIN
3
5
5
Fonctions : Appel par valeur
Appel :
x = 3;
y = 5;
z = maximum(x,y);
afficher(z);
c
5
z
5
5
FONCTION maximum(a, b)
DEBUT
SI a>b ALORS
c=a;
SINON
c=b;
return c;
FIN
Appel :
x = 3;
y = 5;
z = maximum(x,y);
afficher(z);
afficher(c); // ERREUR!
5
Fonctions : Appel par référence
FONCTION maximum(&a, &b)
DEBUT
SI a<b ALORS
a=b;
b
return a; x (et a) y (et b) z
FIN
Appel :
x = 3;
y = 5;
z = maximum(x,y);
afficher(z);
3
5
5
5
7
04/11/2008
Fonctions : Appel par valeur
Appel :
a = 3;
bidon(a);
afficher(a);
FONCTION bidon(x)
DEBUT
x=x+2
FIN
a
x
3
3
5
Fonctions : Appel par référence
FONCTION bidon(&x)
DEBUT
x=x+2
FIN
Appel :
a = 3;
bidon(a);
afficher(a);
a et x
3
5
Fonctions : Appel par valeur
Appel :
x = 3;
bidon(x);
afficher(x);
FONCTION bidon(x)
DEBUT
x=x+2
FIN
x
x (1er appel de la fonction)
3
3
5
5
8