Option informatique en MPSI Méthode de programmation
Algorithme 2
Trois grand paradigmes de la programmation moderne :
La programmation imp´erative repose sur la notion de machine abstraite poss´edant une m´emoire et des
instructions modifiant les ´etats de celle-ci grˆace `a des affectations successives. Cela n´ecessite pour le programmeur
de connaˆıtre en permanence l ?´etat de la m´emoire que le programme modifie, ce qui peut se r´ev´eler une tˆache
complexe.
La programmation fonctionnelle va mettre en avant la d´efinition et l’´evaluation de fonctions pour
r´esoudre un probl`eme, en interdisant toute op´eration d’affectation. Dans ce mode de programmation, la m´emoire
est donc g´er´ee automatiquement et de mani`ere transparente pour le programmeur.
La programmation orient´ee objet s’articule autour des donn´ees d ?un programme. Ceux-ci sont des objets
constitu´es d’attributs les caract´erisant et de m´ethodes les manipulant (ces derni`eres pouvant ˆetre fonctionnelles
ou imp´eratives), l’ensemble des attributs et m´ethodes constituant une classe.
I Algorithme
Origine : Le mot algorithme vient du nom du math´ematicien Al Khuwarizmi (latinis´e au Moyen ˆ
Age
en Algoritmi), qui, au IXe si`ecle ´ecrivit le premier ouvrage syst´ematique sur la solution des ´equations lin´eaires
et quadratiques.
Description : un algorithme est la description en un nombre fini d’´etapes d’un calcul ou de la r´esolution
d’un probl`eme. On peut aussi le d´efinir comme une proc´edure de calcul bien d´efinie qui prend en entr´ee une
valeur, ou un ensemble de valeurs, et qui donne en sortie une valeur ou un ensemble de valeurs.
Exemple : algorithme de tri. On consid`ere une suite de nombres en entr´ee et on obtient, en sortie, une
permutation de la suite de nombres. C’est `a dire une r´eorganisation dans l’ordre croissant par exemple.
Il existe plusieurs algorithmes de tri. L’algorithme optimal pour une application donn´ee d´epend, entre autres
facteurs, du nombre d’´el´ements `a trier.
Un algorithme est dit correct si, pour toute instance en entr´ee, il se termine en produisant une sortie. On
dit que l’algorithme r´esout le probl`eme donn´e.
Un programme est alors la traduction d’un algorithme dans un langage de programmation compr´ehensible
par un ordinateur.
Conception de base :
•Il faut commencer par bien pr´eciser le cahier des charges. C’est `a dire les param`etres d’entr´ee (ou variables),
les r´esultats souhait´es en sorties. Cela sous-entant les conditions sur ces variables et sur la structure du
r´esultat souhait´e.
•Surtout lorsque le but de l’algorithme est complexe il faut proc´eder par raffinements successifs. On parle
de m´ethode d’analyse descendante.
On va donc d´ecomposer le probl`eme en blocs fonctionnels. On essaiera de r´eduire le probl`eme global
jusqu’`a traiter des taches ´el´ementaires.
•Modularit´e : cette d´ecoupe de l’algorithme en blocs doit se faire de telle mani`ere que les blocs soit aussi
ind´ependants que possible les uns des autres.
•Portabilit´e : il faut ´eviter d’abuser de particularit´es d’un langage pr´ecis ou d’une machine donn´ee.
Pr´esentation
•Choisir des identificateurs explicites pour les noms de constantes, types, variables, fonctions et proc´edures.
•Mettre en ´evidence les “blocs” correspondant `a la structure du programme, en utilisant notamment une
indentation convenable.
•Ins´erer des commentaires (* *), pr´ecisant par exemple les sp´ecifications d’un module, des ´el´ements
de justification.
Preuve
Il faut justifier le fait que le programme se termine dans tous les cas. C’est ce qu’on appelle la terminaison.
Et surtout justifier le fait qu’il donne le r´esultat souhait´e. C’est la correction.
Pour cela on peut le tester avec diff´erentes valeurs donn´ees. On peut aussi le prouver math´ematiquement.
Notion de complexit´e 3
II Notion de complexit´e
Un algorithme est une proc´edure effective d´ecrite au moyen d’une s´equence finie d’´etapes de calculs qui vont
transformer les donn´ees en r´esultats. L’efficacit´e ou la performance d’un algorithme d´epend de sa capacit´e `a
minimiser certains crit`eres tr`es importants comme :
•le temps d’ex´ecution qui va d´ependre du nombre d’op´erations `a affectuer
•les ressources mat´erielles n´ecessaires notamment l’espace m´emoire utilis´e
On d´enombre le plus souvent un seul type d’op´eration (en g´en´eral la plus coˆuteuse) : il est bon de pr´eciser
“complexit´e en nombre de comparaisons”(ce sera le cas des algorithmes de tri), “complexit´e en nombre de
multiplications” (pour des algorithmes de calculs comme la multiplication de polynˆomes), . . .
Pour comparer des algorithmes s’appliquant `a un certain type de donn´ees, de taille variable, on d´efinit
une taille de donn´ees N(par exemple : taille d’un tableau, degr´e d’un polynˆome, ordre d’une matrice carr´ee,
longueur d’une liste, . . . ).
Si C(d) d´esigne la complexit´e de l’algorithme ´etudi´e pour le traitement de la donn´ee d, ´el´ement de l’ensemble
D(N) des donn´ees de taille N, on d´efinit :
•la complexit´e dans le pire des cas : Tau pire (N) = max {C(d), d ∈ D (N)};
•la complexit´e dans le meilleur des cas : Tau mieux (N) = min {C(d), d ∈ D (N)};
•la complexit´e en moyenne :
Tmoyen (N) = 1
Card D(N)·X
d∈D(N)
C(d)
(en supposant D(N) fini et les diff´erentes donn´ees ”´equiprobables” !).
La complexit´e dans le pire des cas informe sur le temps maximal de calcul qu’effectue un algorithme.
La complexit´e dans les meilleurs des cas informe sur le temps minimum de calcul qu’effectue un l’algorithme.
C’est par exemple le temps mis par certains algorithmes de tris d’une liste d´ej`a class´ee.
La complexit´e en moyenne renseigne sur le comportement g´en´eral de l’algorithme, mais il n’est pas tr`es facile
de le calculer en g´en´eral. Elle se calcule essentiellement par des techniques issues du calcul probabiliste.
La complexit´e dans le pire des cas est la plus souvent calcul´ee. Cela permet d’´evaluer les algorithmes dans
leur fonctionnement extrˆeme. Pas de mauvaise surprise `a pr´evoir.
Notation Θ (f(N))
Tet f´etant deux fonctions de IN dans IR+,on ´ecrit T(N) = Θ (f(N)) si et seulement si l’on a simultan´ement
T(N) = O(f(N)) et f(N) = O(T(N)) lorsque Ntend vers l’infini, autrement dit s’il existe αet βpositifs
tels que, pour Nassez grand, on ait : αf (N)≤T(N)≤βf (N)(i.e. T(N)et f(N)sont asymptotiquement
du mˆeme “ordre de grandeur”).
La hi´erarchie des ordres de grandeur permet effectivement une comparaison des algorithmes ind´ependamment
de la machine utilis´ee, car les temps de calcul T1(N) et T2(N) sur deux machines de performances diff´erentes
sont grosso modo des fonctions proportionnelles de N(le facteur de proportionnalit´e mesurant la diff´erence de
rapidit´e des deux machines).
On parle de complexit´e :
•logarithmique pour Θ(log2(n))
•lin´eaire pour Θ(n)
•quasi-lin´eaire pour Θ(nlog2(n))
•polynˆomiale pour Θ(nk) avec k > 1
•exponentielle pour Θ(an) avec a > 1
Exemples de temps d’ex´ecution
Le tableau ci-dessous donne des valeurs approch´ees du temps de calcul n´ecessaire `a une machine, capable
d’ex´ecuter 108op´erations par seconde, pour mettre en œuvre des algorithmes de complexit´es vari´ees (les unit´es
j, a, u d´esignant respectivement le jour, l’ann´ee et l’ˆage estim´e de l’univers).
Notion de complexit´e 4
Nlog2N N N log2N N 2N42NN!
5 2.10−8s 5.10−8s 8.10−8s 3.10−7s 6.10−6s 3.10−7s 1.10−6s
10 2.10−8s 1.10−7s 2.10−7s 1.10−6s 1.10−4s 1.10−5s 4.10−2s
20 3.10−8s 2.10−7s 6.10−7s 4.10−6s 2.10−3s 1.10−2s 600 a
50 4.10−8s 5.10−7s 1.10−6s 3.10−5s 6.10−2s 100 j 6.106u
100 5.10−8s 1.10−6s 5.10−6s 1.10−4s 1 s 2.104u
500 6.10−8s 5.10−6s 3.10−5s 3.10−3s 10 min
1 000 7.10−8s 1.10−5s 7.10−5s 1.10−2s 2 h
5 000 9.10−8s 5.10−5s 4.10−4s 0.3 s 70 j
10 000 9.10−8s 1.10−4s 9.10−4s 1 s 3 a
50 000 1.10−7s 5.10−4s 5.10−3s 30 s 2.103a
R´esultats asymptotiques `a connaitre (cf cours de Maths)
Proposition II - 1 :
Pour tous q > 1, α > 0 et β > 0, on a
n
X
k=0
qk= Θ qn+1,
n
X
k=0
kα= Θ nα+1,
n
X
k=0
kαlnβ(n) = Θ nα+1 lnβ(n)
On rencontrera r´eguli`erement des r´ecurrences d’ordre 1, que ce soit en it´eratif ou surtout en r´ecursif. On a
donc besoin des r´esultats suivants :
Proposition II - 2 :
Soient a∈IR∗
+, (bn)n∈IN une suite r´eelle et (un)n∈IN une suite v´erifiant, pour tout n∈IN : un+1 =aun+bn
On a alors les r´esultats suivants :
– si bn=o(nν) et a > 1, alors un= Θ(an)
– si bn∼λbnavec λ > 0 et b < a, alors un= Θ(an)
– si bn∼λanavec λ > 0, alors un= Θ(nan)
– si bn∼λbnavec λ > 0 et b > a, alors un= Θ(bn).
It´eration 5
III It´eration
Lorsqu’une op´eration ou une proc´edure doit ˆetre utilis´ee un certain nombre de fois on utilise alors des boucles
it´eratives. Deux cas sont `a distinguer : lorsqu’on connait le nombre d’it´erations `a faire ou lorsque le nombre est
soumis `a une condition.
Lorsque l’it´eration est destin´ee `a faire ´evoluer des valeurs il est n´ecessaire d’utiliser des r´ef´erences.
1) it´eration conditionnelle : boucle WHILE
Il s’agit du cas o`u la r´ep´etition est conditionn´ee par l’´evaluation d’une expression bool´eenne
L’utilisation de telles boucles n´ecessite une justification claire de la terminaison !
Exemple : (* cherche le plus petit diviseur > 1 de n, n >= 2 *)
Exemple : test de primalit´e
2) It´eration inconditionnelle : boucle FOR
Elles sont utilis´ees lorsqu’on connaˆıt `a l’entr´ee dans la boucle le nombre d’it´erations `a effectuer (en Caml,
instructions for, le compteur de boucle (ou indice de boucle) est une valeur enti`ere).
Attention : La terminaison d’une boucle FOR est assur´ee par la nature mˆeme de la boucle, `a condition
que la valeur du compteur ne soit pas modifi´ee en cours de boucle .
Exemple : factoriel
Exemple : affichage des n premiers carr´es
6
7
8
9
1
/
9
100%
