LOG320 01 CalculsAsymptotiques

Université du Québec
École de technologie supérieure

Département de génie logiciel et des TI
LOG-320
Structures de données et algorithmes
Introduction et
analyse asymptotique
Contacts
Professeurs
– Groupe 01
• Patrick Cardinal
• patrick.cardinal@etsmtl.ca
• A-4486
– Groupe 02
• Pierre Dumouchel (première moitié du cours)
• Patrick Cardinal (deuxième moitié du cours)
– Groupe 03
• Francis Cardinal
• francis.cardinal.1@ens.etsmtl.ca
• A-4526
– Groupe 04
• Pierre Dumouchel
• pierre.dumouchel@etsmtl.ca
• A-4484
– Disponibilités:
• Sur rendez-vous
Chargés de laboratoire/TP
– À déterminer
Le matériel du cours est disponible sur Moodle.

2
Calendrier de la session Été 2020– Groupe 01
Légende:
Cours #1 à 13 Date à retenir:
Labo #1 Examen Intra: 18 juin 2020
Labo #2 Abandon: 15 juillet 2020
Labo #3
Examens finaux
Cours: Mardi 8h30–12h00; 13 périodes au total

TP : Jeudi 8h30-9h30; 12 périodes au total
Labo : Jeudi 9h30-11h30; 12 périodes au total 3
Légende:
Labo #3
Examens finaux
Cours: Mercredi 18h00–21h30; 13 périodes au total

TP : Lundi 18h00-19h00; 12 périodes au total
Labo : Lundi 19h00-21h00; 12 périodes au total 4
Légende:
Labo #3
Examens finaux
Cours: Jeudi 8h30–12h00; 13 périodes au total

TP : Mardi 8h30-9h30; 12 périodes au total
Labo : Mardi 9h30-11h30; 12 périodes au total 5
Légende:
Labo #3
Examens finaux
Cours: Lundi 18h00–21h30; 13 périodes au total

TP : Mercredi 18h00-19h00; 12 périodes au total
Labo : Mercredi 19h00-21h00; 12 périodes au total 6
Sujets abordés dans ce cours
Analyse d’algorithmes • Algorithmes de recherche
– Tris dans les graphes
– Algorithmes de recherche – Algorithme MinMax, alpha-
beta
– Algorithmes récursifs – Algorithme de Dijkstra
– Recherche A*
Structures de données • Algorithmes d’optimisation
– Tableaux, files, piles
– Heap combinatoire
– Arbres binaires – Programmation dynamique
• Arbres binaires de – Algorithmes gloutons
recherche
• Arbres rouge-noir – Branch and bound
• Arbres AVL
• Arbre splay – Algorithmes non-déterministes
– Table de hachage • Recherche de chaîne de
– Graphe caractères
• Autre sujet à déterminer
7
Livre de référence (optionnel)
Introduction to algorithms, 3rd edition

T.H. Cormen, C.E. Leiserson, R.L. Rivest et C. Stein.
The MIT Press, 2009
ISBN-10: 0262033844
ISBN-13: 978-0262033848 8
Évaluations
Évaluations individuelles
• Examen intra (30%) Une moyenne d’au moins 50% aux
• Examen final (30%) évaluations individuelles est exigée pour
réussir le cours. Ceci est une condition
• 2 quizz (5% chacun) nécessaire mais non suffisante.
3 laboratoires:
Algorithmes de compression Mots cachés (variante) Jeu de « Breakthrough»
4 semaines (10%) 2 semaines (5%) 6 semaines (15%)
9
Conditions pour s’inscrire au cours
Pour assurer la tenue de la session d’été 2020 dans le contexte de la
pandémie au Covid19, les modalités particulières suivantes devront être
appliquées :
• La session se fera entièrement à distance.

• L’étudiant inscrit à un cours doit avoir accès à un ordinateur, un
micro, une caméra et un accès à internet, idéalement de 10Mb/s ou
plus.
• Les examens (intra, finaux) se feront à distance, la surveillance de ces
examens se fera à l’aide de la caméra et du micro de l’ordinateur et
pourrait être enregistrée. Ceci est nécessaire pour se conformer aux
exigences du bureau canadien d’agrément des programmes de génie
afin d’assurer la validité des évaluations.
Si vous ne consentez pas aux modalités décrites ci-haut, vous devez vous
désinscrire de vos cours avant le 15 mai et vous pourrez être
remboursés. En demeurant inscrit, vous acceptez les modalités
particulières de la session E20.
10
Algorithme
Algorithme
Une méthode qui doit être suivie pour
résoudre un problème.
• Une recette
Un problème est l’association d’un

ensemble de données d’entrée vers un
ensemble de données de sortie.
Un algorithme prend les données d’entrée

et les transforme en données de sortie
11
Algorithme
Définition de Wikipedia:
Un algorithme est une suite finie d’étapes (instructions
non ambiguë), réalisées dans un ordre déterminé,
appliquées à un nombre fini de données afin d'arriver
avec certitude à un certain résultat, et ce,
indépendamment des données de départ.
12
Source: https://www.geeksforgeeks.org/introduction-to-algorithms/
Algorithme
Un algorithme possède les propriétés
suivantes:
– Données d’entrées doivent être bien définies
– Données de sorties doivent être bien définies
– Il doit être clair et sans ambiguïté
– Il doit être composé d’un nombre fini d’étapes
– Il doit terminer
– Il doit être réalisable
– Il doit être indépendant du langage
13
Pourquoi étudier l’algorithmique?
Les performances sont souvent utilisées pour
déterminer ce qui est possible et ce qui ne
l’est pas.
Les mathématiques algorithmiques forment

un langage qui permet de décrire le
comportement d’une programme
– Exemple : Notation grand-O
Plusieurs algorithmes de la vraie vie font

partie d’un des paradigmes que nous allons
étudier durant la session
14
Spécification d’un algorithme
Organigramme (flowchart)
– Exprime un algorithme en utilisant un ensemble de
figures géométriques décrivant les différentes étapes de
l’algorithme.
– Cette représentation n’est presque plus utilisée.
i=0
min = ∞
i=i+1 min = T[i]

non
oui oui
i<n T[i] < min
non
retourner min
15
Spécification d’un algorithme
Pseudocode
– Mélange d’instructions de type « langage de
programmation » et de langage naturel
(français,anglais,…)
– Notation utilisée dans ce cours:
• Structures de contrôle : pour, tant que, si
• Assignation est représentée par un =
• Égalité représentée par ==
Min(T)
min = ∞
pour chaque e dans T
si e < min
min = e
retourner min
16
Algorithme vs programme
Programme
– Dépend du langage de programmation
– Dépend des choix d’implémentation
– Est souvent optimisé, donc plus difficile à
comprendre
Algorithme
– Ne contient aucun détail d’implémentation
– Ne contient pas de vérification des variables
d’entrées
– Indépendant du contexte d’implémentation (OS,
langage)
– Plus facile à comprendre
17
Algorithme vs programme
Algorithme Programme en C
Min(T) int Min(int *t,int n)

min = ∞ if(t == 0)
pour chaque e dans T return ERROR
si e < min min = 100000
min = e for(int i=0; i<n; i++)
retourner min if(t[i] < min)
min = T[i]
return min
18
Exemple concret en Java
Création d’une chaine de caractère de longueur N
Algorithm(n)
str = ⏀
pour i =1 à n
str = str + {c}
Version 1 Version 2
19
Utilité d’un algorithme
Permet de prouver l’exactitude d’une solution
Permet de déterminer les détails d’implémentation
Permet d’estimer le temps de réponse et la mémoire

de travail utilisée
Permet de séparer le problème en plusieurs sous-

problèmes
Fait office de documentation
20
Meilleur algorithme ou meilleur ordinateur?
Supposons que nous avons un ordinateur qui peut effectuer
10000 opérations par seconde. Que se passe-t-il si on obtient
un ordinateur 10 fois plus rapide?
T(n) 10k 100k Accélération

op/sec op/sec
10n 1,000 10,000 10x
20n 500 5,000 10x
5n log n 250 1,842 7.37x
2n2 70 223 3.18x
2n 13 16 1.23x
21
Analyse d’un algorithme
Il existe souvent plusieurs algorithmes pour
résoudre un même problème.
– Ex: tri
– Ex: trouver le plus grand diviseur commun de deux
nombres
On veut donc choisir l’algorithme le plus efficace:

– Au point de vue de la vitesse d’exécution
– De la quantité de mémoire de travail utilisé
Un autre point peut entrer en ligne de compte: la

simplicité de l’algorithme.
22
Temps versus opérations
Le temps d’exécution varie grandement d’un
ordinateur à un autre et même d’une exécution à
l’autre. Les facteurs suivants peuvent influencer le
temps d’exécution d’un algorithme:
• Le type d’architecture de la machine
• L’implémentation
• Le multitâche
• Etc.
Peut-on trouver une manière indépendante de

comparer l’efficacité des algorithmes?
23
Exemple d’un problème avec plusieurs solutions:
Étant donné un ensemble d’entier x1,x2,..,xN, trouver la
somme d’éléments consécutifs ayant la valeur maximum.
maxSubSum1(T[1..n]) maxSubSum2(T[1..n])
1. maxSum = 0 1. maxSum = 0
2. pour i = 1 à n 2. pour i = 1 à n
3. pour j = i à n 3. sum = 0
4. sum = 0 4. pour j = i à n
5. pour k = i à j 5. sum = sum + T[j]
6. sum = sum + T[k] 6. si sum > maxSum
7. si sum > maxSum 7. maxSum = sum
8. maxSum = sum 8. retourner maxSum
9. retourner maxSum
[Weiss]
24
Analyse expérimentale
Étant donné un ensemble d’entier x1,x2,..,xN, trouver la
200
180
160
140
MaxSumSeq1
Temps (secondes)
120
MaxSumSeq2
100
80
60
40
20
0
0 0,1 0,2 0,3 0,4 0,5 0,6
n Millions
25
Analyse expérimentale
Étant donné un ensemble d’entier x1,x2,..,xn, trouver la
Temps d’exécution (en seconde) de 4 algorithmes pour le problème

de la sous-séquence avec la somme maximale:
Algorithme Algorithme Algorithme Algorithme
O(n3) O(n2) O(n log n) O(n)
N=100 0.000159 0.000006 0.000005 0.000002
N=1 000 0.095857 0.000371 0.000060 0.000022
N=10 000 86.67 0.033322 0.000619 0.000222
N=100 000 Non disponible 3.33 0.006700 0.002205
N=1 000 000 Non disponible Non disponible 0.074870 0.022711
[Weiss]
26
Exemple d’un algorithme:
Algorithme(T[1..n])
1. d=∞
2. pour i = 1 à n
3. pour j = 1 à n
4. si i ≠ j et |T[i] – T[j]| < d
5. d = |T[i] – T[j]|
6. retourner d
Que fait cet algorithme?

Combien de fois chaque ligne est exécutée?
27
Nouvelle version:
Algorithme(T[1..n])
1. d=∞
2. pour i = 1 à n
3. pour j = i+1 à n
4. si |T[i] – T[j]| < d
5. d = |T[i] – T[j]|
6. retourner d
Combien de fois chaque ligne est exécutée?
28
Que fait cet algorithme?
F( T[ 1.. n ] )
1. pour i = 1 à n-1
2. min = T[i]
3. indexMin = i
4. pour j = i+1 à n
5. si T[j] < min
6. min = T[j]
7. indexMin = j
8. T[indexMin] = T[i]
9. T[i] = min
29
Tri par sélection
i min
5 7 3 6 2 8
i min
F( T[ 1.. n ] ) 2 7 3 6 5 8
1. pour i = 1 à n-1 i min
2. min = T[i]
2 3 7 6 5 8
3. indexMin = i
4. pour j = i+1 à n i min
5. si T[j] < min

2 3 5 6 7 8
6. min = T[j]
i min
7. indexMin = j
8. T[indexMin] = T[i] 2 3 5 6 7 8
9. T[i] = min
i min
2 3 5 6 7 8
2 3 5 6 7 8 30
Coût Nombre exact
d’exécutions
TriSélection( T[ 1.. n ] )
1. pour i = 1 à n-1 c1 𝑛
2. min = T[i] c2 𝑛−1
3. indexMin = i c3 𝑛−1
$
𝑛(𝑛 + 1)
4. pour j = i+1 à n c4 !𝑖 = −1
2
!"#
$
𝑛(𝑛 − 1)
5. si T[j] < min c5 !(𝑖 − 1) =
2
!"%
$
6. min = T[j] c6 𝑛(𝑛 − 1)
!(𝑖 − 1) =
2
!"%
$
7. indexMin = j c7 𝑛(𝑛 − 1)
!(𝑖 − 1) =
2
!"%
8. T[indexMin] = T[i] c8 𝑛−1
9. T[i] = min c9 𝑛−1
𝑐+ + 𝑐, + 𝑐- + 𝑐. / 𝑐+ − 𝑐, − 𝑐- − 𝑐.
𝑇 𝑛 = 𝑛 + 𝑐0 + 𝑐/ + 𝑐1 − + 𝑐2 + 𝑐3 𝑛 − (𝑐/ +𝑐1 + 𝑐+ + 𝑐24𝑐3 )
2 2
31
Analyse d’une fonction
Analyse détaillée d’un algorithme:
– Avantage :Très précise
– Désavantage : Long à calculer
Solution: Analyser asymptotiquement le

comportement de l’algorithme lorsque la
taille des données en entrée tend vers
l’infini:
– Avantage: Facile à calculer
– Désavantage: Moins précis
32
Analyse Asymptotique
Pourquoi veut-on analyser l’algorithme avec des
données d’entrée de grande taille?
100
400 4000
80
300 3000
60
200 2000
40
20 100 1000
0 0 0
0 25 50 75 100 0 75 150 225 300 0 150 300 450 600 750 900
Analyse asymptotique permet de comprendre

comment se comporte un algorithme lorsque la taille
des données d’entrée augmente.
33
Analyse Asymptotique
Il y a 5 notations standards que l’on peut utiliser:
Grand-O
f(n) est en O(g(n)) si f(n) est asymptotiquement plus petit ou égale à g(n)
Grand-Oméga
f(n) est en Ω(g(n)) si f(n) est asymptotiquement plus grand ou égale à g(n)
Grand-Thêta
f(n) est en Θ(g(n)) si f(n) est asymptotiquement est égale à g(n)
Petit-oh
f(n) est en o(g(n)) si f(n) est asymptotiquement strictement plus petit à g(n)
Petit-omega
f(n) est en 𝜔(g(n)) si f(n) est asymptotiquement strictement plus grand à g(n)
34
Notation O
Définition formelle
f(n) ∈ O(g(n)) s’il existe deux constantes positives n0
et c tel que f(n) ≤ cg(n) pour tout n>n0
f(n) = O(g(n))
cg(n)
f(n)
temps
n0 n
Une fonction f(n) ∈ O(g(n)) ssi:

' $
lim ( $ < ∞
$→& 35
Notation-O (Analyse d’un algorithme)
Cherche une fonction simple qui décrit le comportement de
l’algorithme dans le pire cas.
– Exemples : O(n), O(n2), O(lg n)
L’analyse est simplifiée selon les règles suivantes:

– Les constantes sont éliminées
– Seul le monôme avec le degré le plus élevé est conservé
Exemple: 4000
f(n) vs n2
f(n) = 3n2+5n+4 est en O(n2) 3500
3000
2500
f(n)
2000
f(n)
1500
n2
1000
500
0
0 10 20 30 40 50 60 36
n (taille des données)
Tri par insertion
Copyright © The McGraw-Hill Companies, Inc. Permission required for reproduction or display.
37
Tri par insertion
InsertionSort( T[ 1.. n ] ) L’algorithme considère que le tableau a deux sections:
1. pour j = 2 à n • la section triée
2. key = T[j] • la section non triée
3. i = j -1
4. tant que i > 0 et T[i]>key
Au départ, la section trié ne contient que le premier
élément.
5. T[i+1] = T[i] j
6. i = i-1
5 7 3 6 2 8
7. T[i+1] = key
Ensuite, à chaque itération, un nouvel élément sera

inséré au bon endroit dans la section triée du tableau.
Donc, à chaque itération, la taille de la section triée va

augmenté d’un élément jusqu’à ce que le tableau soit
complètement trié.
38
Tri par insertion
j
InsertionSort( T[ 1.. n ] ) 5 7 3 6 2 8
1. pour j = 2 à n j
2. key = T[j]
5 7 3 6 2 8
3. i = j -1
5. T[i+1] = T[i]
6. i = i-1
7. T[i+1] = key
39
Tri par insertion
j
2. key = T[j]
5 7 6 2 8 key 3
3. i = j -1
j
5. T[i+1] = T[i] key
5 7 6 2 8 3
6. i = i-1
j
7. T[i+1] = key
5 7 6 2 8 key 3
j
3 5 7 6 2 8
40
Tri par insertion
j
2. key = T[j]
3. i = j -1
3 5 7 2 8 key 6
4. tant que i > 0 et T[i]>key j
5. T[i+1] = T[i]
3 5 7 2 8 key 6
6. i = i-1
j
7. T[i+1] = key
3 5 6 7 2 8
41
Tri par insertion
j
2. key = T[j]
3. i = j -1 3 5 6 7 8 key 2
4. tant que i > 0 et T[i]>key j
5. T[i+1] = T[i]
3 5 6 7 8 key 2
6. i = i-1
j
7. T[i+1] = key
3 5 6 7 8 key 2
j
3 5 6 7 8 key 2
j
3 5 6 7 8 key 2
j
2 3 5 6 7 8 42
Tri par insertion
j
2. key = T[j]
3. i = j -1 2 3 5 6 7 8
5. T[i+1] = T[i]
6. i = i-1
7. T[i+1] = key
43
Notation-O (Analyse d’un algorithme)
Nombre exact d’exécutions Analyse
asymptotique
(Pire cas)
InsertionSort( T[ 1.. n ] )
1. pour j = 2 à n 𝑛 𝑂(𝑛)
2. key = T[j] 𝑛−1 𝑂(𝑛)
3. i = j -1 𝑛−1 𝑂(𝑛)
$
4. tant que i > 0 et T[i]>key !𝑖 =
𝑛(𝑛 + 1)
−1 𝑂(𝑛/ )
2
!"#
$
5. T[i+1] = T[i] !(𝑖 − 1) =
𝑛(𝑛 − 1)
𝑂(𝑛/ )
2
!"#
$
6. i = i-1 𝑛(𝑛 − 1)
!(𝑖 − 1) =
2 𝑂(𝑛/ )
!"#
7. T[i+1] = key 𝑛−1 𝑂(𝑛)
T(n) = O(3n2+4n)
= O(n2)
44
Notation Ω
f(n) ∈ Ω(g(n)) s’il existe deux constantes positives n0
et c tel que f(n) ≥ cg(n) pour tout n>n0
f(n) = W(g(n))
f(n)
cg(n)
temps
n0 n
Une fonction f(n) ∈ Ω(g(n)) ssi:

' $
lim ( $ >0
$→& 45
Notation-W (Analyse d’un algorithme)
Nombre exact d’exécutions Analyse
asymptotique
(Pire cas)
InsertionSort( T[ 1.. n ] )
1. pour j = 2 à n 𝑛 Ω(𝑛)
2. key = T[j] 𝑛−1 Ω(𝑛)
3. i = j -1 𝑛−1 Ω(𝑛)
$
4. tant que i > 0 et T[i]>key !1 = 𝑛 − 1 Ω(𝑛)
&"#
5. T[i+1] = T[i] 0 Ω(1)
6. i = i-1 0 Ω(1)
7. T[i+1] = key 𝑛−1 Ω(𝑛)
T(N) = W(5n+2)
= W(n)
46
Notation Θ
f(n) ∈ Q(g(n)) s’il existe trois constantes positives n0,c1
et c2 tel que c1g(n) <= f(n) <= c2g(n) pour tout n>n0
f(n) = Q(g(n))
c1 g(n)
f(n)
c2 g(n)
temps
n0 n
n0
Une fonction f(n) ∈ Θ(g(n)) ssi:

' $
lim ( $ ≠ 0, ∞
$→& 47
Notation-Q (Analyse d’un algorithme)
Analyse du pire cas Analyse meilleur cas
SelectionSort( T[ 1..n ] )
1. pour i =1 à n-1 𝑛 𝑂(𝑛) 𝑛 Ω(𝑛)

2. min =T[i] 𝑛−1 𝑂(𝑛) 𝑛−1 Ω(𝑛)
3. indexMin =i 𝑛−1 𝑂(𝑛) 𝑛−1 Ω(𝑛)
$ $
4. pour j =i+1 à n 𝑛(𝑛 + 1) 𝑛(𝑛 + 1)
!𝑖 =
2
−1 𝑂(𝑛/ ) !𝑖 =
2
−1 Ω(𝑛/ )
!"# !"#
$ $
𝑛(𝑛 − 1) 𝑛(𝑛 − 1)
5. si T[j] < min !𝑖 − 1 = 𝑂(𝑛/ ) !𝑖 − 1 = Ω(𝑛/ )
2 2
!"# !"#
$
𝑛(𝑛 − 1)
6. min =T[j] !𝑖 − 1 = 𝑂(𝑛/ ) 0
!"#
2 Ω(1)
$
7. indexMin =j 𝑛(𝑛 − 1)
!𝑖 − 1 = 𝑂(𝑛/ ) 0 Ω(1)
2
!"#
8. T[indexMin] =T[i] 𝑛−1 𝑂(𝑛) 𝑛−1 Ω(𝑛)
9. T[i] =min 𝑛−1 𝑂(𝑛) 𝑛−1 Ω(𝑛)
T(N) = O(N2) et T(N) = W(N2) Þ T(N) = Q(N2)

48
Notation-Q (Analyse d’un algorithme)
Analyse W Analyse O
InsertionSort( T[ 1..n ] )
1. pour j = 2 à n Ω(𝑛) 𝑂(𝑛)

2. key = T[j] Ω(𝑛) 𝑂(𝑛)
3. i = j-1 Ω(𝑛) 𝑂(𝑛)
4. tant que i > 0 et T[i]>key Ω(𝑛) 𝑂(𝑛/ )
5. T[i+1] = T[i] Ω(1) 𝑂(𝑛/ )
6. i = i-1 Ω(1) 𝑂(𝑛/ )
7. T[i+1] = key Ω(𝑛) 𝑂(𝑛)
49
Autres notations
Petit o
- La fonction g(n) doit être strictement plus grande
- f(n) ∈ o(g(n)) s’il existe deux constantes positives n0 et
c tel que f(n) < cg(n) pour tout n>n0
- Exemple:
- 3𝑛! + 2 ∈ 𝑂 𝑛!
- 3𝑛! + 2 ∈ 𝑂 𝑛"
- 3𝑛! + 2 ∈ 𝑜 𝑛"
- 3𝑛! + 2 ∉ 𝑜 𝑛!
Petit oméga
- La fonction f(n) doit être strictement plus petite
- f(n) ∈ 𝜔(g(n)) s’il existe deux constantes positives n0 et
c tel que f(n) > cg(n) pour tout n>n0
- Exemple:
- 3𝑛! + 2 ∈ Ω 𝑛!
- 3𝑛! + 2 ∈ Ω 𝑛
- 3𝑛! + 2 ∈ 𝜔 𝑛
- 3𝑛! + 2 ∉ 𝜔 𝑛!
50
Baromètres
Qu’est-ce qu’un baromètre?
– C’est une instruction qui s’exécute au moins autant de fois que chacune
des autres.
Comment ça fonctionne?
– Sélectionne un ensemble d’instructions significatives B={b1…bk}
– Détermine le nombre d’exécutions de chacun des baromètres dans B
– Temps total est la somme du nombre d’exécutions de chaque baromètre
Comment choisir l’ensemble B?
– Mettre systématiquement certains types
d’instructions(boucles,conditions,etc.)
– Estimer leurs nombres d’exécution maxima et minima selon que l’on
calcule le meilleur ou le pire cas.
– Simplifier B en gardant seulement les instructions qui s’exécutent le plus
souvent.
51
Baromètres: Sélection des instructions
Mettre dans B les instructions suivantes.

1. points d’entrée des fonctions.
2. boucles tant que.
3. conditionnels si.
4. une instruction au moins dans chaque bloc.
• bloc = ensemble d’instructions de même
indentation qui s’exécutent le même nombre de
fois.
52
Baromètres: sélection des instructions
1. F( T [ 0.. n [ ) bloc: 1, 2, 3, 9
2. i=0
3. tant que i < n
4. si T[ i ] > 0 bloc: 4, 8
5. j=0 bloc: 5, 6
6. tant que j < T [ i ]
7. j=j*2 bloc: 7
8. incrementer i
9. imprimer « j ai fini »
B = 1, 3, 4, 6, 7
53
Baromètres: exemple
Soit l‘algorithme suivant : De quelles variables dépend le
1. F( T [ 0.. n[ ) temps d’exécution?
2. i = 0
N et R=max(T)
3. tant que i < n
4. si T[ i ] > 0 Baromètres ?
5. j=0 Déterminer Emin Emax
6. tant que j < T [ i ]
instruction Emin Emax
7. j=j+1 1 1 1
3 N N
8. incrementer i 4 N N
9. imprimer « j ai fini » 6 0 N*R
7 0 N*R
Donc T(N) = W(N) et T(N) = O(N*R)

54
Baromètres: exemple
Analyse W Analyse O
BubbleSort(T[1..n])
1. pour i = 1 à n W(n) O(n)

2. pour j = n à i+1 W(n2) O(n2)
3. if T[j] < T[j-1] W(n22) O(n2)
4. temp = T[j] W(1) O(n2)
5. T[j] = T[j-1]
6. T[j-1] = temp
55
Analyse asymptotique
Trois algorithmes de tri:
Meilleur cas Pire cas
Tri à bulle W(n2) O(n2)
Tri par sélection W(n2) O(n2)
Tri par insertion W(n) O(n2)
Dans le pire des cas et avec le même nombre de données à trier,

est-ce que le temps d’exécution sera identique?
56
Comparaison des trois algorithmes (C++):
Nombres sélectionnés au hasard Données triés
400000 500000
350000
400000
300000
250000 300000
200000
150000 200000
100000
100000
50000
0 0
0 200000 400000 600000 800000 1000000 0 200000 400000 600000 800000 1000000
Tri par selection Tri par insertion Tri à bulles Tri par selection Tri par insertion Tri à bulles
Ordre lexicographique Données triés

400000 1
350000
300000 0,8
250000 0,6
200000
150000 0,4
100000
0,2
50000
0 0
0 200000 400000 600000 800000 1000000 0 200000 400000 600000 800000 1000000 1200000
Tri par sélection Tri par insertion Tri à bulles Tri par selection Tri par insertion Tri à bulles
57
Comparaison des trois algorithmes (Python):
Nombres sélectionnés au hasard Données triés
700 400
600 350
500 300
250
400
200
300
150
200 100
100 50
0 0
0 10000 20000 30000 40000 50000 60000 70000 0 10000 20000 30000 40000 50000 60000 70000
Tri par sélection Tri par insertion Tri à bulles Tir par sélection Tri par insertion Tri à bulles
Ordre lexicographique Données triés

500 0,1
450 0,09
400 0,08
350 0,07
300 0,06
250 0,05
200 0,04
150 0,03
100 0,02
50 0,01
0 0
0 10000 20000 30000 40000 50000 60000 0 10000 20000 30000 40000 50000 60000 70000
Tri par sélection Tri par insertion Tri à bulles Tir par sélection Tri par insertion Tri à bulles
58
Exercice 1
Quel est l’ordre de cet algorithme?
Algorithme(T[1..n])
1. sum = 0
2. x=1
3. tant que x < n
4. sum = sum+T[x]
5. x = x*2
6. retourner sum
59
Exercice 2
Quel est l’ordre de cet algorithme?
Algorithme(T[1..n])
1. sum = 0
2. x=2
3. tant que x < n
4. sum = sum+T[x]
5. x = x2
6. retourner sum
60
Classes de complexité (communes)
n! 2n n3
n2
T(n)
n*log(n)
log(n)
log log(n)
Constant
n
61
Simplifier les séries
Sommes ou produits avec un nombre variable de termes.
Série Formule Résultat Exemple Q-
équivalente
constante åk=1..N a aN 3+3+...+3(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)/2 1+2+...+10 N2
somme de carrés åk=1..N k2 N(N+1)(2N+1)/6 1+22+32+..102 N3
somme de åk=1..N ka (a entier) 1+23+33+..103 (a=3) Na+1

puissances
å de polynômes de åk=1..N Pa(k) åk=1..N k(k+1)..(k+a) Na+1
degré a
géométrique binaire åk=0..N 2k 2N+1-1 1+2+4+..+128 2N
géométrique entière åk=0..N ak (a entier) (aN+1-1)/(a-1) 1+3+9+..+81 (a=3) aN
factorielle Õk=1..N k N!»Ö2pN (N/e)N 1*2*..*100 NN+0.5
62
Analyse de la mémoire de travail
Même principe que pour le temps d’exécution mais on
considère la dimension des variables et tableaux.
Analyse W Analyse O
CreateAndFillMatrix(n,m )
1. C[1..n,1..m] : matrice W(n*m) O(n*m)

2. pour i = 1 à n W(1) O(1)
3. pour i = 1 à m W(1) O(1)
4. ci,j = max(C[i,j-1],C[i-1,J]+l) W(1) O(1)
5. C[i,j] = ci,j W(1) O(1)
6. retourner C[1..n,1..m] W(1) O(1)
Mémoire de travail : Q(n*m)

63
Question “entrevue”
Générer la liste des nombres premiers plus petit que n.
Vérifier_Naïf( n ) SieveOfEratosthenes( n )
pour i = 2 à n-1 flags[1..n] = {Vrai,…,Vrai}
si n % i == 0 nombrePremier = 2
retourner Faux tant que nombrePremier <= 𝑛
retourner Vrai pour i = nombrePremier2 à n
flag[i] = Faux
Vérifier_meilleur( n ) i = i+nombrePremier
pour i = 2 à 𝑛 suivant = nombrePremier+1
si n % i == 0 tant que suivant < n et flags[suivant]==Faux
retourner Faux suivant = suivant+1
retourner Vrai nombrePremier = suivant
retourner flags
64
Conclusion
Ce qu’on a vu aujourd’hui
– Algorithmes de tri
– Calculer le temps d’exécution.
• Précisément
• Asymptotiquement
Même méthode appliquée pour déterminer la

mémoire de travail.
La semaine prochaine:
– Les fonctions récursives
– Calcul de l’ordre asymptotique des fonctions
récursives
65

LOG320 01 CalculsAsymptotiques

Transféré par

Informations du document

Titre original

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

LOG320 01 CalculsAsymptotiques

Transféré par

Droits d'auteur :

Formats disponibles

Université du Québec

École de technologie supérieure

Le matériel du cours est disponible sur Moodle.

Cours: Mardi 8h30–12h00; 13 périodes au total

Cours: Mercredi 18h00–21h30; 13 périodes au total

Cours: Jeudi 8h30–12h00; 13 périodes au total

Cours: Lundi 18h00–21h30; 13 périodes au total

Introduction to algorithms, 3rd edition

• La session se fera entièrement à distance.

Un problème est l’association d’un

Un algorithme prend les données d’entrée

Les mathématiques algorithmiques forment

Plusieurs algorithmes de la vraie vie font

i=i+1 min = T[i]

Min(T) int Min(int *t,int n)

Permet de déterminer les détails d’implémentation

Permet d’estimer le temps de réponse et la mémoire

Permet de séparer le problème en plusieurs sous-

Fait office de documentation

T(n) 10k 100k Accélération

On veut donc choisir l’algorithme le plus efficace:

Un autre point peut entrer en ligne de compte: la

Peut-on trouver une manière indépendante de

Temps d’exécution (en seconde) de 4 algorithmes pour le problème

Que fait cet algorithme?

Combien de fois chaque ligne est exécutée?

5. si T[j] < min

8. T[indexMin] = T[i] c8 𝑛−1

9. T[i] = min c9 𝑛−1

Solution: Analyser asymptotiquement le

Analyse asymptotique permet de comprendre

Une fonction f(n) ∈ O(g(n)) ssi:

L’analyse est simplifiée selon les règles suivantes:

f(n) = 3n2+5n+4 est en O(n2) 3500

Ensuite, à chaque itération, un nouvel élément sera

Donc, à chaque itération, la taille de la section triée va

4. tant que i > 0 et T[i]>key j

7. T[i+1] = key 𝑛−1 𝑂(𝑛)

Une fonction f(n) ∈ Ω(g(n)) ssi:

5. T[i+1] = T[i] 0 Ω(1)

7. T[i+1] = key 𝑛−1 Ω(𝑛)

Une fonction f(n) ∈ Θ(g(n)) ssi:

1. pour i =1 à n-1 𝑛 𝑂(𝑛) 𝑛 Ω(𝑛)

8. T[indexMin] =T[i] 𝑛−1 𝑂(𝑛) 𝑛−1 Ω(𝑛)

9. T[i] =min 𝑛−1 𝑂(𝑛) 𝑛−1 Ω(𝑛)

T(N) = O(N2) et T(N) = W(N2) Þ T(N) = Q(N2)

1. pour j = 2 à n Ω(𝑛) 𝑂(𝑛)

4. tant que i > 0 et T[i]>key Ω(𝑛) 𝑂(𝑛/ )

5. T[i+1] = T[i] Ω(1) 𝑂(𝑛/ )

6. i = i-1 Ω(1) 𝑂(𝑛/ )

7. T[i+1] = key Ω(𝑛) 𝑂(𝑛)

Mettre dans B les instructions suivantes.

Donc T(N) = W(N) et T(N) = O(N*R)

1. pour i = 1 à n W(n) O(n)

4. temp = T[j] W(1) O(n2)

Tri à bulle W(n2) O(n2)

Tri par sélection W(n2) O(n2)

Tri par insertion W(n) O(n2)

Dans le pire des cas et avec le même nombre de données à trier,

Ordre lexicographique Données triés

Ordre lexicographique Données triés

constante åk=1..N a aN 3+3+...+3(10 fois) N

somme de logs åk=1..N log(k) log(N!) log(2)+log(3)+..log(100) N log(N)

factorielle Õk=1..N k N!»Ö2pN (N/e)N 12..*100 NN+0.5

1. C[1..n,1..m] : matrice W(nm) O(nm)