La présentation est en train de télécharger. S'il vous plaît, attendez

La présentation est en train de télécharger. S'il vous plaît, attendez

Structures de données IFT-2000 Abder Alikacem Analyse dalgorithmes Département dinformatique et de génie logiciel Édition Septembre 2009.

Présentations similaires


Présentation au sujet: "Structures de données IFT-2000 Abder Alikacem Analyse dalgorithmes Département dinformatique et de génie logiciel Édition Septembre 2009."— Transcription de la présentation:

1 Structures de données IFT-2000 Abder Alikacem Analyse dalgorithmes Département dinformatique et de génie logiciel Édition Septembre 2009

2 Plan Notions danalyses dalgorithmes Introduction Efficacité des algorithmes Analyse dalgorithmes Notation Ω (big-omega) Notation Θ Notation o (little-oh) Notation O (big-oh) Baromètres Comparaison entre les classes de complexité Règles de simplification Espace mémoire Compromis espace/temps

3 Algorithmique Conception de méthodes pour la résolution de problèmes Description des données Description des méthodes Preuve de bon fonctionnement Complexité des méthodes Efficacité : temps de calcul, espace nécessaire,... Complexité intrinsèque, optimalité Réalisation - implémentation Organisation des objets Opérations élémentaires

4 Efficacité des algorithmes Habituellement on mesure lefficacité dun algorithme (correct) par sa vitesse. Cest-à-dire la durée que met lalgorithme à produire ses résultats. On veut savoir combien de temps cela prend de résoudre une instance I du problème P: données(I) + Algorithme(P) ==> résultat(I). temps mis ?

5 Efficacité des algorithmes Ici, on sintéresse au temps de calcul pour résoudre I: en microsecondes, cycles dhorloge, nombre dinstructions exécutées, etc.. On prend en compte la taille des données(I): en bits, entiers, nombres denregistrements... Parfois, on considère aussi la mémoire nécessaire.

6 Efficacité des algorithmes Approche empirique: mesure de performances. essayer lalgorithme sur différents jeux de données bien choisis. Avantages: résultats réalistes. Inconvénients: coûteux et long dépend du processeur, de lOS et de la charge dépend de limplémentation pas toujours généralisable.

7 Efficacité des algorithmes Approche algorithmique: estimer le nombre de pas de lalgorithme en fonction de la taille des données. Avantages: résultats généraux: on ne dépend pas du processeur, de lOS ou de limplémentation Estimation rapide et peu coûteux évite de se fourvoyer. Inconvénients: prédictions approximatives.

8 Efficacité des algorithmes Les approches empiriques et algorithmique sont complémentaires. Utiliser lapproche algorithmique pour déterminer comment le temps de calcul varie avec la taille des données. Utiliser lapproche empirique afin dobtenir un temps dexécution précis. (associé à une implantation, à un système d'exploitation, et à un type de compilateur particuliers) Avantage: estimer le temps que prend lalgorithme pour des tailles de données plus grands que ceux des tests effectifs.

9 Efficacité des algorithmes Comment choisir parmi les différentes approches pour résoudre un problème? Exemple: Liste chaînée ou tableau? 2 objectifs à atteindre: 1.Concevoir un algorithme facile à comprendre, coder et déboguer. 2.Concevoir un algorithme qui utilise de façon efficace les ressources de lordinateur.

10 Efficacité des algorithmes Objectif (1): concerne le génie logiciel Objectif (2): Algorithmes et structures de données. Lorsque lobjectif (2) est important, comment peut-on mesurer lefficacité dun algorithme?

11 Analyse dalgorithme Analyse empirique: exécuter le programme Analyse assymptotique dalgorithmes Ressources critiques: temps, espace mémoire,... Facteurs affectant le temps dexécution: machine, language, programmeur, compilateur, algorithme et structure de données. Le temps dexécution dépend du volume de lentrée.

12 Analyse dun algorithme Analyse détaillée : Avantage :Très précise Désavantage : Long à calculer Solution: Analyse asymptotique du comportement de lalgorithme lorsque le(s) paramètre(s) de lalgorithme tendent vers linfini: Avantage: Parfois facile à calculer Désavantage: Parfois moins précis Mesure indépendante de l'implémentation : Temps d'exécution d'un algorithme = fonction(taille du problème)

13 Notation (big-omega) Détermine une borne inférieure Définition formelle : f(n) = (g(n)) sil existe deux constantes positives n0 et c tel que cg(n) n0

14 Notation (big-omega) Étant donné deux fonctions f(n) et g(n), f(n) = (g(n)) ssi: b > 0, n, f(n) / g(n) >= b Lim n f(n) / g(n) + Exemple f(n) = 3n 2 +6n+4 et g(n) = n+3 lim n f(n) / g(n) = 3n 2 +6n+4 est (n+3) 3n 2 +6n+4 est (n) On dit « f(g) est en oméga g(n) »

15 Notation Relation déquivalence, correspond à la complexité exacte Définition formelle : f(n) = (g(n)) sil existe trois constantes positives n0,c1 et c2 tel que c1g(n) n0

16 Notation Étant donné deux fonctions f(n) et g(n), f(n) = (g(n)) ssi: a,b > 0, n, a <= f(n) / g(n) <= b Lim n f(n) / g(n) Exemple: f(n) = 3n2+6n+4 et g(n) = n2+3 lim n f(n) / g(n) = 3n2+6n+4 est (n2+3) 3n2+6n+4 est (n2) Autre propriété: f(n) = (g(n)) ssi f(n) = O (g(n)) et f(n) = (g(n))

17 Notation o (little-oh) Détermine une borne supérieure stricte Définition formelle : f(n) = O(g(n)) sil existe deux constantes positives n0 et c tel que f(n) n0

18 Notation O (big-oh) Détermine une borne supérieure Définition formelle : f(n) = O(g(n)) sil existe deux constantes positives n0 et c tel que f(n) n0

19 Notation O (big-oh) Cherche une fonction simple qui décrit le comportement de lalgorithme dans le pire cas. Exemples : O(n), O(n 2 ),O(log n) Lanalyse est simplifié selon les règles suivantes: Les constantes sont éliminées Seul le monôme avec le degré le plus élevé est conservé Exemple: f(n) = 3n 2 +5n+4 est O(n 2 )

20 Exemple void triSelection(int tab[MAXTAB], int n) { int PositionMin, temp, i, j; for (i = n-1; i > 0; i--) { PositionMin = i; for (j = 0; j < i; j++) { if (tab[j] < tab[PositionMin]) { PositionMin = j; } temp = tab[i]; tab[i] = tab[PositionMin]; tab[PositionMin] = temp; }

21 void triSelection(int tab[MAXTAB], int n) { int PositionMin, temp, i, j; for (i = n-1; i > 0; i--) { PositionMin = i; //b1 for (j = 0; j < i; j++) { if (tab[j] < tab[PositionMin]) { PositionMin = j; } temp = tab[i]; tab[i] = tab[PositionMin]; tab[PositionMin] = temp; } // i * a //b2 Quest-ce quun baromètre? Comment ça fonctionne? Comment choisir le choisir ? Baromètres

22 Quest-ce quun baromètre? Cest une instruction qui sexécute au moins autant de fois que chacune des autres. Comment ça fonctionne?: Sélectionne un ensemble dinstructions significatives B={b 1 …b k } On détermine le nombre dexécution de chacun des baromètres dans B Temps total est la somme du nombres de dexécution de chaque baromètre Comment choisir lensemble B? Mettre systématiquement certains types dinstructions(boucles,conditions,etc.) Estimer leurs nombres dexécution maximal et minimal selon que lon calcul le meilleur ou le pire cas. Simplifier B en gardant seulement les instructions qui sexécutent le plus souvent.

23 Baromètres Boucle tant que (pour): chaque fois quon passe dessus, il sexécute le nombre de fois que la condition est vraie+1 (quand la condition est fausse). Bloc interne dun while: chaque fois quon passe sur le while, on passe sur ses instructions autant de fois que la condition est vraie. Bloc interne dun si: chaque fois quon passe sur le si et que la condition est vraie, on passe sur ses instructions Autres instructions: chaque fois quon passe dessus, elles sexécutent une fois.

24 Exemple (suite) for (i = n-1; i>0; i--) { Coût b1 /* PositionMin = i */ Coût i*a; /* pour exécuter la boucle interne*/ Coût b2; /* pour l'échange de tab[i] et tab[PositionMin] */ }

25 Exemple (suite) b = b1 + b2

26 f(n) = an 2 + bn + c a = , b = , c = 0.1 nf(n)an 2 % du n

27 Retour sur la notation O( ) (big-oh) Évaluer le coût d'un algorithme Rechercher la fonction g(n) qui est la plus proche au dessus ou égale à f(n). Nous dirons alors f(n) est O(g(n)).

28 Notation O(g(n)) (big-oh) Pour un nombre n assez grand f(n) an 2 Temps d'exécution d'un algorithme A est f(n) = an 2 + bn + c g(n) = n 2 On écrit : A est O(n 2 ) On lit : l'algorithme A tourne en O(n 2 ) Classes : O(1), O(n), O(n 2 ), O(n 3 ), O(log n), …

29 f(n)f(n) 1 log n n 2 n 2n2n Notation O(g(n)) (big-oh) Classes : O(1), O(n), O(n 2 ), O(n 3 ), O(log n), … n

30 Comparaison entre les classes xVSlog(x) x VS log(x)

31 Comparaison entre les classes x x log( x ) xVSx log(x) x VS x log(x)

32 Comparaison entre les classes x 2 VSx log(x) x 2 VS x log(x)

33 Comparaison entre les classes xVSx 2 VSx 3 x VS x 2 VS x 3

34 Comparaison entre les classes O(1) < O(log(n)) < O(n) < O(nlog(n)) < O(n 2 ) < O(n 3 ) < O(2 n ) < O(10 n )

35 Comparaison entres les classes O(1). Constant ou borné parfait. O(log(n)). Logarithmique excellent O(n). Linéairetrès bon O(n log(n) ) bon. O(n a ) polynomialacceptable O(a n )exponentiel inacceptable O(n!)factorielbeurk.

36 Augmenter la puissance du PC ?

37 Augmenter la puissance du PC

38 Meilleur algorithme ou ordinateur? On suppose que lordinateur utilisé peut effectuer 10 6 opérations à la seconde

39 Exemple (suite et fin) b = b1 + b2 Lalgorithme est en O(n 2 )

40 int minimumOn2(int tableau[],int taille) { int i,j; for(i=0;i

41 Autres exemples Fusionner(x,y) n = taille(x)+taille(y) pour i=1:n …. v(i) = ….. ….. fin Résoudre(P(n)) Si n = 1,...cest fini Sinon A=Résoudre(P(1:n/2)) B=Résoudre(P(n/2+1:n)) Fusionner(A,B) pour i=1:n s = 0; pour j=i:n s =s+A(i,j)*b(i) Fin c(i)=s fin O(nlog 2 n) O(n)O(n) O(n2)O(n2) Ab=c

42 Simplifier les séries Sommes ou produits avec un nombre variable de termes. SérieFormuleRésultatExempleO() constante k=1..N a aN (10 fois)N somme de logs k=1..N log(k) log(N!)log(2)+log(3)+..log(100)N log(N) arithmétique k=1..N k N(N+1)/ N2N2 somme de carrés k=1..N k 2 N(N+1)(2N+1)/ N3N3 somme de puissances k=1..N k a (a entier) (a=3)N a+1 de polynômes de degré a k=1..N Pa(k) k=1..N k(k+1)..(k+a) N a+1 géométrique binaire k=0..N 2 k 2 N N2N géométrique entière k=0..N a k (a entier) (a N+1 -1)/(a-1) (a=3)aNaN factorielle k=1..N kN! 2 N (N/e) N 1*2*..*100N N+0.5

43 Pire cas, meilleur cas et cas moyen Toutes les entrées dune longueur donnée ne nécessitent pas le même temps dexécution. Exemple. Recherche séquentielle dans un tableau de taille n: Commencer au début du tableau et considérer chaque élément jusquà ce que lélément cherché soit trouvé. Meilleur cas: O (1) Pire cas: O (n) Cas moyen: O (n/2)

44 Règles de simplification 1. Toujours négliger les constantes multiplicatives : 2n 2 = O(n 2 ) 2. Négliger les termes dordre inférieur : 5n 2 + 3n = O(n 2 ) + O(n) = O(n 2 ) 3. O(n 2 ) x O(n 3 ) = O(n 5 )

45 Règles de simplification Si f(n) O(g(n)) et g(n) O(h(n)), alors f(n) O(h(n)).

46 Règles de simplification Si f(n) O(kg(n)) où k >0 est une constante alors f(n) O(g(n)).

47 Règles de simplification Si f1(n) O(g1(n)) et f2(n) O(g2(n)), alors f1(n) + f2(n) O(max(g1(n), g2(n))). Exemple : n + nlog n O(nlog n)

48 Règles de simplification Si f1(n) O(g1(n)) et f2(n) O(g2(n)) alors f1(n)*f2(n) O(g1(n) * g2(n)) Exemple : (3n 2 +3)(n 2 +5nlog n) O(n 4 )

49 Règles de simplification Si p(n) est un polynôme de degré k alors p(n) (n k )

50 Règles de simplification log k (n) O(n) pour toute constante k>0

51 log k (n) = O(n) log k (n) cn 1 lim n log k (n) cn = lim n k(k 1)log k2 (n) k log k1 (n) cn lim n = cn = (règle de lHôpital)... = lim n k!k! cn = 0

52 Exemples Exemple 1: a = b; Temps constant: (1). Exemple 2: somme = 0; for (i=1; i<=n; i++) somme += n; Temps: (n)

53 Exemples Exemple 3: somme = 0; for (i=1; i<=n; i++) for (j=1; j<=i; j++) somme++; Temps: (1) + O (n 2 ) = O (n 2 ) On peut montrer : (n 2 )

54 Exemples Exemple 4: somme = 0; for (j=1; j<=n; j++) for (i=1; i<=n; i++) somme++; for (k=0; k

55 Exemples Exemple 5: somme = 0; for (k=1; k<=n; k*=2) for (j=1; j<=n; j++) somme++; Temps: (nlog n)

56 Exemples lSum = 0; for( int i = 0; i < n; ++i ) lSum++; lSum = 0; for( int i = 0; i < n; ++i ) for( int j = 0; j < n; ++j) lSum++;

57 Exemples lSum = 0; for( int i = 0; i < n; ++i ) lSum++; for( int j = 0; j < n; ++j) lSum++; lSum = 0; for( int i = 0; i < n; ++i ) for( int j = 0; j < n*n; ++j) lSum++;

58 Exemples lSum = 0; for( int i = 0; i < n; ++i ) for( int j = 0; j < i; ++j) lSum++; lSum = 0; for( int i = 0; i < n; ++i ) for( int j = 0; j < n*n; ++j) for( int k = 0; k < j; ++k) lSum++;

59 Exemples lSum = 0; for( int i = 1; i <= n; ++i ) for( int j = 1; j < i*i; ++j) if( j % i == 0) for( int k = 0; k < j; ++k) lSum++;

60 Analyse de problèmes Borne supérieure: Borne supérieur sur le meilleur algorithme connu. Borne inférieure: Borne inférieure sur tous les algorithmes possibles. Exemple: Trier un tableau de taille n nécessite O(n) étapes et peut se faire en O(nlog n) étapes.

61 Temps de calcul Exemple T(n) = O(n 4 ). De combien le temps de calcul augmente-t-il si n est multiplié par 10 ? T(n) = O(n 4 ) = cn 4 T(10n) = c(10n) 4 = 10 4 cn 4 = T(n)

62 Logarithmes log b (n) = k b k = n log b (n) = log a (n) / log a (b) log b (n) = O(log(n)) (la base ne compte pas) Le log apparaît lorsque systématiquement, on découpe le problème en deux morceaux de même taille

63 Logarithmes et exposants log(xy) = log(x) + log(y) log(x a ) = alog(x) a (b+c) = a b a c a bc = (a b ) c

64 Temps de calcul Exemple T(n) = O(n logn). De combien le temps de calcul augmente-t-il si n est multiplié par 10 ? T(n) = cn log(n) T(10n) = c(10n) log(10n) T(10n) = 10cn log(n) + 10cn log(10) T(10n) = 10T(n) + dn

65 Recherche binaire point milieu données initialement triées

66 Analyse par télescopage T(n) = T(n/2) + O(1) T(n/2) = T(n/4) + O(1) T(n/4) = T(n/8) + O(1) …. = …. T(2) = T(1) + O(1)

67 Analyse par télescopage T(n) = T(n/2) + O(1) T(n/2) = T(n/4) + O(1) T(n/4) = T(n/8) + O(1) …. = …. T(2) = T(1) + O(1)

68 Analyse par télescopage T(n) = T(n/2) + O(1) T(n/2) = T(n/4) + O(1) T(n/4) = T(n/8) + O(1) …. = …. T(2) = T(1) + O(1)

69 Analyse par télescopage T(n) = T(n/2) + O(1) T(n/2) = T(n/4) + O(1) T(n/4) = T(n/8) + O(1) …. = …. T(2) = T(1) + O(1)

70 Analyse par télescopage T(n) = T(n/2) + O(1) T(n/2) = T(n/4) + O(1) T(n/4) = T(n/8) + O(1) …. = …. T(2) = T(1) + O(1)

71 Analyse par télescopage T(n) = T(n/2) + O(1) T(n/2) = T(n/4) + O(1) T(n/4) = T(n/8) + O(1) …. = …. T(2) = T(1) + O(1) T (n)= T (1) + O(1) = O(log n) i=1 log n

72 Temps de calcul Exemple T(n) = O( log n). De combien le temps de calcul augmente-t-il s i n est multiplié par 1000 ? T(n) = c log(n) T(1000n) = c log(1000n) T(1000n) = c log(n) + c log(1000) T(1000n) = T(n) + 10c

73 Code source template int binarySearch( const vector & a, const Comparable & x ) { int low = 0; int high = a.size( ) - 1; int mid; while( low < high ) { mid = ( low + high ) / 2; if( a[ mid ] < x ) low = mid + 1; else high = mid; } return ( low == high && a[ low ] == x ) ? low : NOT_FOUND; }

74 Limitation de lanalyse Si on pense que T(n) = Θ ( f(n)), on peut valider expérimentalement T(n)/f(n) = c Considérez des n suffisamment grands Lors de lanalyse, on choisit souvent le pire des cas, mais celui-ci peut être significativement pire que le cas moyen !

75 Limitation de lanalyse T(n)/f(n)

76 Espace mémoire La quantité despace mémoire utilisé peut aussi être étudiée à laide de lanalyse asymptotique. En général: Temps: Algorithme manipulant les structures de données. Espace: Structure de données

77 Compromis espace/temps Il est souvent possible de réduire le temps dexécution au prix daugmenter lespace mémoire et vice versa. Fichiers compressés Table des valeurs dune fonctions Insérer un nœud dans une liste chaînée Espace disque: Un programme sera dautant plus rapide quil requiert peu daccès disque.


Télécharger ppt "Structures de données IFT-2000 Abder Alikacem Analyse dalgorithmes Département dinformatique et de génie logiciel Édition Septembre 2009."

Présentations similaires


Annonces Google