1 Généralité

Universit´e de Provence Algorithmique et
Licence Math-Info Programmation en Python
Premi`ere Ann´ee
V. Phan Luong
Cours 5 : Notions d’Algorithme et de Complexit´e
1 G´en´eralit´e
Un algorithme est une m´ethode effective pour r´esoudre un probl`eme. Par les termes
“m´ethode effective” on s’entend que la m´ethode peut r´eellement r´esoudre le probl`eme
en un nombre fini d’op´erations dont l’ex´ecution peut se faire en un temps fini. La
sp´ecification d’un algorithme se faire d’abord par la sp´ecification formelle du probl`eme
qu’il r´esoudre, suivie d’une m´ethode qu’il adopte pour r´esoudre le probl`eme.
Il faut bien analyser le probl`eme pour le comprendre et d´eterminer les donn´ees essentielles
du probl`eme et ce que l’on cherche comme solution. Les donn´ees essentielles du probl`eme
constituent ce que l’on appelle l’entr´ee de l’algorithme. Ce que cherche le probl`eme
constitue la sortie de l’algorithme.
Par exemple, le probl`eme de calculer le pgcd de deux entiers naturels a pour l’entr´ee les
deux entiers et la sortie le plus grand commun diviseur de ces deux entiers.
La m´ethode de r´esolution est sp´ecifi´ee en un nombre fini d’´etapes dont chacune ex´ecute
une op´eration bien connue et finie pour assurer que chaque ´etape termine et que l’algo-
rithme termine en un temps fini. Une bonne connaissance du domaine d’application est
n´ecessaire pour pouvoir sp´ecifier une m´ethode de r´esolution d’un probl`eme `a r´esoudre.
Un algorithme est efficace si sa m´ethode de r´esolution optimise l’espace de m´emoire
et le temps de calcul pour r´esoudre le probl`eme. L’efficacit´e est estim´ee par la no-
tion de complexit´e. On a donc la complexit´e en espace de m´emoire et la complexit´e
en temps d’ex´ecution. Ces complexit´es sont estim´ees en fonction de la grandeur des
donn´ees d’entr´ee du probl`eme. Dans l’ordre de plus efficace au moins efficace, on peut
citer les algorithmes dont l’estimation est en fonction logarithme, lin´eaire, quadratique,
exponentielle de la grandeur des donn´ees d’entr´ee.
Pour estimer de mani`ere ind´ependante de tous ordinateurs, l’efficacit´e en temps d’ex´ecution
est calcul´ee en nombre d’op´erations de base de l’agorithme. Par exemple, pour un
1

algorithme de calcul du pgcd, la complexit´e en temps peut ˆetre estim´ee en nombre
d’op´erations de division.
Dans la suite on ´etudie certain nombre d’algorithmes concernant les listes.
2 Recherche dans une liste
2.1 Liste non tri´ee
Probl`eme de recherche d’un ´el´ement dans une liste.
Entr´ee : un ´el´ement x et une liste L.
Sortie : un index de la liste si x existe dans L, -1 sinon.
M´ethode :
Informelle : Parcourir la liste en comparant chaque ´el´ement de L avec x. On s’arrˆete lors
de la premi`ere rencontre de x et retourne l’index de cette rencontre. Si la liste est toute
parcourue et on ne voit pas x, alors retourne -1.
Formelle :
Pour chaque case de la liste, commencant par la premi`ere case, faire
Comparer x avec l’´el´ement de la case ;
Si x est identique `a l’´el´ement, alors retourner l’index courant et s’arrˆete.
Sinon, passer `a la case suivante
Si on arrive `a ce stade, alors retourner -1
Fonction Python :
def cherche(x, L) :
i, n = 0, len(L)
while i < n :
if x == L[i] : return i
i=i+1
return -1
## appels de fonction
print cherche (5, [4,7,5,3,6,1])
2

print cherche (5, [4,7,4,3,6,1])
La complexit´e en nombre de comparaisons de donn´ees (l’op´eration x == L[i]) :
– Au pire, on doit comparer x avec tous les ´el´ements de L. Donc, soit n le nombre
d’´el´emements de L, alors la complexit´e en nombre de comparaisons de donn´ees est n ;
elle est en fonction lin´eaire de la grandeur de la liste.
– Au meilleur, on voit x `a la premi`ere case de la liste. La complexit´e est en une compa-
raison.
– La commplexit´e moyenne est n/2.
2.2 Liste tri´ee
On peut toujours appliquer l’algorithme ci-dessus pour rechercher un ´el´ement dans une
liste tri´ee. Cependant, pour cette configuration sp´eciale, on autre algorithme plus efficace
qui effectue la recherche de mani`ere dichotomique.
Probl`eme de recherche d’un ´el´ement dans une liste tri´ee.
Entr´ee : un ´el´ement x et une liste tri´ee L.
Sortie : un index de la liste si x existe dans L, -1 sinon.
M´ethode :
Si la liste est vide, alors retourne -1.
Sinon,
Comparer x avec l’´el´ement au milieu de la liste.
Si x est ´egal `a cet ´el´ement, alors retourner l’index du milieu.
Sinon, si x est sup´erieur `a cet ´el´ement, alors re-appliquer la recherche dans la partie
droite de la liste.
Sinon, re-appliquer la recherche dans la partie gauche de la liste.
3

Fonction Python :
# fonction iterative
def cherch_ord(x, L):
g, d = 0, len(L) - 1
while g <= d :
m = (d + g)/2
if x == L[m]:
return m
elif x > L[m]:
g=m+1
else :
d=m-1
if g > d : return -1
#else: return -1
# fonction recursive
def cherch_ord_r(x, L, g, d):
if g <= d :
m = (d + g)/2
if x == L[m]:
return m
elif x > L[m]:
return cherch_ord_r(x, L, m+1, d)
else :
return cherch_ord_r(x, L, g, m-1)
if g > d : return -1
#else: return -1
# Tests
L = [4, 6, 7, 9, 12, 15, 35, 56]
4

x = input(’Entrer un nombre: ’)
print "Test de la fonction it´erative: "
print cherch_ord(x, L)
print "Test de la fonction r´ecursive: "
g, d = 0, len(L) - 1
print cherch_ord_r(x, L, g, d)
La complexit´e en nombre de comparaisons de donn´ees (l’op´eration x == L[i]) :
– Au meilleur, on voit x `a la case au milieu de la liste. La complexit´e est en une compa-
raison.
– Au pire, on doit comparer x avec l’´el´ement au milieu des parties divis´ees successivement
de L, jusqu’`a ce que la derni`ere partie (de longueur 1). Pour atteindre cette longueur, le
nombre de divisions successives est log2(n), car 2log2(n)=n.
3 Tris dans une liste
3.1 Un tri simple
La m´ethode de tri (dans l’ordre croissant) la plus intuitive est de rechercher d’abord
l’´el´ement minimal de la liste, le placer au d´ebut de la liste et recommencer le tri dans la
queue de la liste, ainsi de suite jusqu’`a ce que la queue de la liste courant est vide.
Entr´ee : une liste L.
Sortie : la mˆeme liste mais tri´ee dans l’ordre croissant.
M´ethode : trier par permutation.
Parcourir L `a partir du premier ´el´ement, pour chaque ´el´ement faire
Pour la partie de la liste commen¸cant par l’´el´ement courant,
chercher un ´el´ement minimal de cette partie ;
permuter l’´el´ement minimal avec l’´el´ement au d´ebut de la partie.
Retourner la liste.
5