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

Efficacité des algorithmes(suite) Objectif (1): concerne le génie logiciel Objectif (2): Algorithmes et structures de données. Lorsque l’objectif (2) est important, comment peut-on mesurer l’efficacité d’un algorithme?

Comment mesurer l’efficacité? Comparaison empirique: (exécuter le programme) Analyse assymptotique d’algorithmes Ressources critiques: temps, espace mémoire,... Facteurs affectant le temps d’exécution: machine, language, programmeur, compilateur, algorithme et structure de données. Le temps d’exécution dépend de la longueur de l’entrée. Ce temps est une fonction T(n) où n est la longueur de l’entrée. Empirical comparison is difficult to do “fairly” and is time consuming. Critical resources: Time. Space (disk, RAM). Programmers effort. Ease of use (user’s effort). Factors affecting running time: Machine load. OS. Compiler. Problem size. Specific input values for given problem size.

Exemples Exemple 1. // Retourne l’indice du plus grand élément int largest(int T[], int n) { int max = 0; for (int i=1; i<n; i++) if (T[max] < T[i]) max = i; return max; } As n grows, how does T(n) grow? Cost: T(n) = c1n + c2 steps

Exemples (suite) Exemple 2: x=3; Exemple 3: sum = 0; for (i=1; i<=n; i++) for (j=1; j<=n; j++) sum++; } Example 2: Constant cost. Example 3: Cost: T(n) = c1n2 + c2. Roughly n2 steps, with sum being n2 at the end. Ignore various overhead such as loop counter increments.

Pire cas, meilleur cas et cas moyen Toutes les entrées d’une longueur donnée ne nécessitent pas le même temps d’exé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: Pire cas: Cas moyen: Best: Find at first position. Cost is 1 compare. Worst: Find at last position. Cost is n compares. Average: (n+1)/2 compares IF we assume the element with value K is equally likely to be in any position in the array.

Meilleur algorithme ou ordinateur? How much speedup? 10 times. More important: How much increase in problem size for same time expended? That depends on the growth rate. n: Size of input that can be processed in one hour (10,000 steps). n’: Size of input that can be processed in one our on the new machine (100,000 steps). Note: for 2n, if n = 1000, then n’ would be 1003. On suppose que l’ordinateur utilisé peut effectuer 106 opérations à la seconde

Taux de croissance

Analyse assymptotique: Grand O Définition: Soit T(n) une fonction non négative. T(n) est dans O(f(n)) s’il existe deux constantes positives c et n0 t.q. T(n)  cf(n) pour tout n > n0. Utilité: Le temps d’exécution est Signification: Pour toutes les grandes entrées (i.e., nn0), on est assuré que l’algorithme ne prend pas plus de cf(n) étapes.  Borne supérieure. Must pick one of [best, average, worst] to complete the statement. Big-oh notation applies to some set of bounds.

Notation grand-O (suite) La notation grand-O indique une borne supérieure sur le temps d’exécution. Exemple: Si T(n) = 3n2 +2 alors T(n)  O(n2). On désire le plus de précision possible: Bien que T(n) = 3n2 +2  O(n3), on préfère O(n2). It provides more information in this example to say O(n2) than O(n3).

Grand-O: Exemples Exemple 1: Initialiser un tableau d’entiers for (int i=0; i<n; i++) Tab[i]=0; Il y a n itérations Chaque itération nécessite un temps  c, où c est une constante. Le temps est donc T(n)  cn Donc T(n)  O(n) We are doing average case. cs is a constant. The actual value is irrelevant.

Grand-O: Exemples Exemple 2: T(n) = c1n2 + c2n . c1n2 + c2n  c1n2 + c2n2  (c1 + c2)n2 pour tout n  1. T(n)  cn2 où c = c1 + c2 et n0 = 1. Donc, T(n) est dans O(n2). Exemple 3: T(n) = c. On écrit T(n)  O(1).

Grand-Omega Definition: Soit T(N), une fonction non négative. On a T(n)  (g(n)) S,il existe deux constantes positives c et n0 telles que T(n)  cg(n) for all n > n0. Signification: Pour de grandes entrées, l’exécution de l’algorithme nécessite au moins cg(n) étapes.  Borne inférieure.

Grand-Omega: Exemple T(n) = c1n2 + c2n. c1n2 + c2n  c1n2 pour tout n > 1. T(n)  cn2 pour c = c1 et n0 = 1. Ainsi, T(n) est dans (n2) par la définition. On veut la plus grande borne inférieure.

La notation Theta Lorsque le grand-O et le grand-omega d’une fonction coïncides, on utilise alors la notation grand-theta. Définition: Le temps d’exécution d’un algorithme est dans (h(n)) s’il est à la fois dans O(h(n)) et dans (h(n)). For polynomial equations on T(n), we always have . There is no uncertainty, since once we have the equation, we have a “complete” analysis.

O(lg n)  O(n)  O(n2)  O(n3)  O(2n) Exemple (n) (n2) (n3) (2n) (lg n) How much speedup? 10 times. More important: How much increase in problem size for same time expended? That depends on the growth rate. n: Size of input that can be processed in one hour (10,000 steps). n’: Size of input that can be processed in one our on the new machine (100,000 steps). Note: for 2n, if n = 1000, then n’ would be 1003. O(lg n)  O(n)  O(n2)  O(n3)  O(2n)

Une erreur fréquente “Le meilleur cas pour mon algorithme est n=1 car c’est le plus rapide.” FAUX! On utilise la notation grand-O parce qu’on s’intéresse au comportement de l’algorithme lorsque n augmente. Meilleur cas: on considère toutes les entrée de longueur n. We are doing average case. cs is a constant. The actual value is irrelevant.

Une erreur fréquente Confondre le pire cas avec la borne supérieure. La borne supérieur réfère au taux de croissance. Le pire cas réfère à l’entrée produisant le plus long temps d’exécution parmi toutes les entrées d’une longueur donnée.

Règles de simplification 1 f(n) O(g(n)) et g(n)  O(h(n)), alors f(n)  O(h(n)). 2. Ignore constants. 3. Drop low order terms. 4. Useful for analyzing loops.

Règles de simplification 2 f(n)  O(kg(n)) où k > 0, alors f(n)  O(g(n)). 2. Ignore constants. 3. Drop low order terms. 4. Useful for analyzing loops.

Règles de simplification 3 f1(n)  O(g1(n)) et f2(n)  O(g2(n)), alors (f1 + f2)(n)  O(max(g1(n), g2(n))). 2. Ignore constants. 3. Drop low order terms. 4. Useful for analyzing loops.

Règles de simplification 4 f1(n)  O(g1(n)) et f2(n)  O(g2(n)) alors f1(n)f2(n)  O(g1(n) g2(n)) n)). 2. Ignore constants. 3. Drop low order terms. 4. Useful for analyzing loops.

Exemples Exemple 1: a = b; Temps constant: (1). Exemple 2: somme = 0; for (i=1; i<=n; i++) somme += n; Temps: (n) Asymptotic analysis is defined for equations. We need to convert programs to equations to analyze them. The traditional notation is (1), not (c). (n) even though the value of sum is n2.

Exemples Exemple 3: somme = 0; for (j=1; j<=n; j++) for (i=1; i<=n; i++) somme++; for (k=0; k<n; k++) A[k] = k; Temps: (1) + (n2) + (n) = (n2) First statement is (1). Double for loop is i = (n2). Final for loop is (n). Result: (n2).

Exemples Example 4: On peut montrer : (n2) somme = 0; for (i=1; i<=n; i++) for (j=1; j<=i; j++) somme++; Temps: (1) + O(n2) = O(n2) On peut montrer : (n2) First loop, sum is n2. Second loop, sum is (n+1)(n)/2. Both are (n2).

Exemples Example 5: somme = 0; for (k=1; k<=n; k*=2) for (j=1; j<=n; j++) somme++; Temps: (nlog n) First loop is n for k = 1 to log n, or (n log n). Second loop is 2k for k = 0 to log n - 1, or (n).

Recherche dychotomique Combien d’éléments sont examinés dans le pire cas?

Recherche dychotomique // Retourne la position de l’élément K // dans un tableau trié de taille n int binaire(int array[], int n, int K) { int l = -1; int r = n; while (l+1 != r) { int i = (l+r)/2; if (K < array[i]) r = i; if (K == array[i]) return i; if (K > array[i]) l = i; } return n;

Autres exemples On analyse les boucles while comme les boucles for. Instruction if: maximum entre le if et le then switch: maximum parmi les différents cas Appels de fonction: Temps d’exécution de la fonction if statement: The probabilities for the then/else clauses being executed must be independent of n. switch statement: The probabilities of the various clauses being executed must be independent of n.

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. Analyzing problems is done a lot in a senior algorithms class.

Analyse de problèmes : Exemple Remarque: Il n’y a aucune différence entre les bornes inférieure et supérieure lorsque le temps d’exécution exact est connu. Exemple de connaissance imparfaite: 1. Coût des E/S: (n). 2. Tri par insertion et selection: O(n2). 3. Meilleurs tris (Quicksort, Mergesort, Heapsort, etc.): O(n log n). The examples so far have been easy in that exact equations always yield . Thus, it is hard to distinguish  and O. This example should help to explain the difference. Bounds are used to describe our level of uncertainty about an algorithm.

Espace mémoire La quantité d’espace mémoire utilisée peut aussi être étudiée à l’aide de l’analyse assymptotique. Temps: Algorithme manipulant les structures de données. Espace: Structure de données

Le principe du compromis espace/temps Il est souvent possible de réduire le temps d’exécution au prix d’augmenter l’espace mémoire et vice versa. Fichiers compressés Table des valeurs d’une fonctions Insérer un nœud dans une liste chaînée Espace disque: Un programme sera d’autant plus rapide qu’il requiert peu d’accès disque.

Retour aux listes Comparaison des implémentations Listes avec tableau: Insertion et retrait sont (n). Précédent et accès direct sont (1). Tout l’espace est alloué à l’avance. Pas d’espace autre que les valeurs. Listes chaînées: Insertion et retrait sont (1). Précédent et accès direct sont (n). L’espace augmente avec la liste. Chaque élément requiert de l’espace pour les pointeurs. Applies to both average and worst cases.

Comparaison de l’espace utilisé E: Espace mémoire pour les valeurs. P: Espace mémoire pour les pointeurs. D: Nombre d.éléments dans le tableau. DE = n(P + E) n = DE P + E