Algorithmique

Leçon 3 : Calcul de complexité :

Le cas itératif

2020/2021 Algorithmique - Alain Silovy 1

 Calcul de complexité : Le cas itératif
Rappel de la définition : Comment le temps d’exécution dépend
de la taille des données (ici, n, la taille de la liste ls)

Exemple : Le tri par sélection (code Python)

temps nb. exéc
def tri_select(ls):
n = len(ls) a 1
for i in range(n - 1):
pMin = i b n-1
for j in range(i + 1, n):
if ls[j] < ls[pMin]: c σ𝑛−2
𝑖=0 (𝑛 − 𝑖 − 1)
pMin = j
ls[i], ls[pMin] = ls[pMin], ls[i] inclus dans b

2020/2021 Algorithmique - Alain Silovy 2

 Un peu d’algèbre
𝑛

෍ 𝑓 𝑖 ≡ 𝑓 0 + 𝑓 1 + . . . + 𝑓(𝑛) 1) Définition de la notation

𝑖=0

෍ 1 = 1 + 1 + . . . + 1 (𝑛 + 1 𝑓𝑜𝑖𝑠) = 𝑛 + 1 2) On somme n+1 fois le nombre 1

𝑖=0

𝑛
𝑛(𝑛 + 1)
෍𝑖 = 0 + 1 + 2 + ...+ 𝑛 = 3) Gauss
2
𝑖=0

෍(𝑓(𝑖) + 𝑔(𝑖)) = ෍ 𝑓(𝑖) + ෍ 𝑔(𝑖) 4) Réorganisation de somme

𝑖 𝑖 𝑖

෍ 𝑎. 𝑓(𝑖) = 𝑎. ෍ 𝑓 𝑖 5) Factorisation
𝑖 𝑖

2020/2021 Algorithmique - Alain Silovy 3

 Un peu d’algèbre
Exemple bref de calcul :

Le if ls[j] < ls[pMin]: de l’algorithme est exécuté σ𝑛−2

𝑖=0 (𝑛 − 𝑖 − 1) fois.

Or :

σ𝑛−2 𝑛−2 𝑛−2 𝑛−2

𝑖=0 (𝑛 − 𝑖 − 1) = σ𝑖=0 𝑛 - σ𝑖=0 𝑖 - σ𝑖=0 1

Par exemple :

σ𝑛−2
𝑖=0 𝑛 = n. σ𝑛−2
𝑖=0 1 (formule 5) = n.(n – 2 + 1) (formule 2) = n.(n – 1)

Le temps total pris par ce if est donc c fois (le résultat de ce calcul)

2020/2021 Algorithmique - Alain Silovy 4

 Fin de l’algèbre (ouf ! ☺)

Le temps total du calcul est de la forme :

A.n2 + B.n + C

2020/2021 Algorithmique - Alain Silovy 5

 Comportement asymptotique (n » 1)

Les algorithmiciens sont masos. n est très (très) grand :

• B.n » C (quels que soient B et C)
• A.n2 » B.n (quels que soient A et B)

Donc le temps est ≈ A.n2

Mais A n’a pas d’importance

On écrit alors : T(n)  2

O(n )
2020/2021 Algorithmique - Alain Silovy 6
 Exemples de complexité : n = len(ls)
def f1(ls):
s = 0
i = 0
while i < len(ls):
s += ls[i]
i += 1
return s

T(n)  O(n)
2020/2021 Algorithmique - Alain Silovy 7
 Exemples de complexité : n = len(ls)
def f1_variante(ls):
s = 0
i = 0
while i < len(ls) // 2: # divisé par 2
s += ls[i]
i += 1
return s

T(n)  O(n)
2020/2021 Algorithmique - Alain Silovy 8
 Exemples de complexité : n = len(ls)
def f2(ls):
s = 0
i = 0
while i < len(ls):
j = 0
while j < len(ls):
s += ls[i] + ls[j]
j += 1
i += 1
return s

T(n)  2
O(n )
2020/2021 Algorithmique - Alain Silovy 9
 Exemples de complexité : n = len(ls)
def f3(ls):
s = 0
i = 0
j = 0 # initialization de j sortie de la boucle
while i < len(ls):
while j < len(ls):
s += ls[i] + ls[j]
j += 1
i += 1
return s

T(n)  O(n)
2020/2021 Algorithmique - Alain Silovy 10
 Exemples de complexité : n = len(ls)
def f4(ls):
s = 0
i = 0
while i < len(ls):
j = 0
while j < i: # i vaut n / 2 en moyenne
s += ls[i] + ls[j]
j += 1
i += 1
return s

T(n)  2
O(n )
2020/2021 Algorithmique - Alain Silovy 11
 Exemples de complexité : n = len(ls)
def f5(ls):
s = 0
i = 0
while i < len(ls) and ls[i] != 0:
s += ls[i]
i += 1
return s

T(n)  O(n)
(en pire cas quand ls[i] n’est jamais zéro)

2020/2021 Algorithmique - Alain Silovy 12

 Exemples de complexité : n = len(ls)
def f6(ls):
s = 0
i = 0
while i < len(ls):
s += ls[i]
i += 2 # (i += 2 ou i += 1 ne change rien)
return s

T(n)  O(n)
2020/2021 Algorithmique - Alain Silovy 13
 Exemples de complexité : n = len(ls)
def f7(ls):
s = 0
i = len(ls) - 1
while i > 1:
s += ls[i]
i //= 2 # i divisé par 2 à chaque tour
return s

T(n)  O(log n)
2020/2021 Algorithmique - Alain Silovy 14
 Exemples de complexité : n = len(ls)
def f8(ls):
s = 0
i = 1
while i < len(ls):
s += ls[i]
i *= 2 # Cette fois, i multiplié par 2 à chaque tour
return s

T(n)  O(log n)
2020/2021 Algorithmique - Alain Silovy 15
 Exemples de complexité : n = len(ls)
def f9(ls):
s = 0
i = 0
while i < len(ls):
j = 1
while j < len(ls):
s += ls[i] + ls[j]
j *= 2
i += 1
return s

T(n)  O(n x log n)

2020/2021 Algorithmique - Alain Silovy 16
 Discussion
Avez-vous réfléchi au problème du kème plus petit élément d’un tableau ?
Par exemple si le tableau est [7, 4, 5, 4, 2], alors :
• Le 0ème plus petit est 2 (le plus petit ou le minimum)
• Le 1ème plus petit est 4 (ainsi que le 2ème plus petit)
• Le 4ème plus petit est 7 (le plus grand ou maximum)

Bien sûr, trier le tableau et renvoyer tab[k] donne le résultat. Mais est-ce
vraiment nécessaire de tout trier ?
Pouvez-vous faire mieux ?

2020/2021 Algorithmique - Alain Silovy 17

 Exercices
1. Quelle est la complexité de la fonction suivante ?

def max(ls):
if len(ls) == 0:
raise ValueError("arg is an empty sequence")
m = ls[0]
for x in ls:
if x > m:
m = x
return m

2020/2021 Algorithmique - Alain Silovy 18

 Exercices
2. Quelle est la complexité de la fonction suivante ?

def max3(a, b, c):

m = a
if b > m:
m = b
if c > m:
m = c

2020/2021 Algorithmique - Alain Silovy 19

 Exercices
Solution de l’exercice 01.1 :
def suppr_at_pos(tab, pos):
if pos < 0 or pos >= len(tab):
return
for i in range(pos, len(tab) - 1):
tab[i] = tab[i + 1]
tab.pop()

3. Quelles est la complexité de la fonction suppr_at_pos ?

2020/2021 Algorithmique - Alain Silovy 20

 Exercices
Solution de l’exercice 01.2 :

def suppr_all_val2(tab, val):

def suppr_all_val1(tab, val):
dest = 0
pos = 0
for orig in range(len(tab)):
while pos < len(tab):
if tab[orig] != val:
if tab[pos] == val:
tab[dest] = tab[orig]
suppr_at_pos(tab, pos)
dest += 1
else:
del tab[dest : ]
pos += 1

4. Quelles sont les complexités de ces deux fonctions ?

2020/2021 Algorithmique - Alain Silovy 21

 Exercices
5. Quelle est la complexité de la fonction suivante ?

def tri_bulle(ls):
for i in range(len(ls) - 1, 0, -1):
for j in range(i):
if ls[j] > ls[j + 1]:
ls[j + 1], ls[j] = ls[j], ls[j + 1]

2020/2021 Algorithmique - Alain Silovy 22

 Exercices
6. Quelle est la complexité de la fonction suivante ?

def tri_insertion(ls):
for i in range(1, len(ls)):
j = i
val = ls[i]
while j > 0 and val < ls[j - 1]:
ls[j] = ls[j - 1]
j -= 1
ls[j] = val

2020/2021 Algorithmique - Alain Silovy 23

 Exercices
7. Quelle est la complexité de la fonction suivante ?

def dicho_search(ls, val):

"""
Précondition : ls doit être triée (en ordre croissant)
Renvoie la position dans ls où doit apparaître val
"""
d, f = 0, len(ls)
m = (d + f) // 2
while d < f and ls[m] != val:
if val < ls[m]:
f = m
else:
d = m + 1
m = (d + f) // 2
return m

2020/2021 Algorithmique - Alain Silovy 24

 Exercices
8. Ecrivez, dans le langage de programmation de votre choix, une fonction
fusion qui reçoit deux listes (tableaux) triées et qui renvoie une nouvelle
liste avec tous les éléments des deux listes dans l’ordre. Par exemple si la
fonction reçoit les deux listes [3, 5, 6, 9] et [1, 2, 4, 4, 8],
votre fonction renverra la liste [1, 2, 3, 4, 4, 5, 6, 8, 9]
Pour cet exercice vous devez produire un nouveau tableau. L’algorithme
ne fonctionne pas en place !
En Java, par exemple :
public static List<Integer> fusion(
List<Integer> ls1,
List<Integer> ls2
);
Quelle est la complexité de cette fonction ?
9. Continuez les exercices de la séance précédente si vous n’avez pas
terminé
2020/2021 Algorithmique - Alain Silovy 25