Support de cours pour AP1-algo et AP2-algo

42 Pages·2008·0.31 MB·French

Support de cours pour AP1-algo et AP2-algo
Christine Solnon
2007-2008
2
Table des matiŁres
1 Introduction 5
1.1 Notion d’algorithme . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
1.2 Introduction (cid:224) la structure d’un ordinateur . . . . . . . . . . . . . . . . . . . . . . . . . . 7
1.3 DØmarche pour la rØsolution d’un problŁme . . . . . . . . . . . . . . . . . . . . . . . . . . 8
2 Variables, Expressions et A(cid:27)ectations 11
2.1 Les variables . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11
2.1.1 Nom d’une variable . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11
2.1.2 Type d’une variable . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12
2.1.3 Valeur d’une variable. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12
2.2 Description des variables dans un algorithme . . . . . . . . . . . . . . . . . . . . . . . . . 13
2.3 L’a(cid:27)ectation. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14
2.4 DØ(cid:28)nition d’une expression . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14
2.4.1 OpØrations arithmØtiques . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14
2.4.2 OpØrations de comparaison . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14
2.4.3 OpØrations logiques . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15
2.4.4 Exemple . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15
2.5 Saisie et a(cid:30)chage de donnØes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16
3 Encha(cid:238)nement d’instructions 17
3.1 Encha(cid:238)nement sØquentiel . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17
3.2 Encha(cid:238)nement alternatif . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17
3.3 Encha(cid:238)nement rØpØtitif . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19
4 Appels de procØdures et fonctions 25
4.1 ParamŁtres e(cid:27)ectifs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25
4.2 ParamŁtres en entrØe et en sortie . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27
4.3 ProcØdures et fonctions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 28
4.4 Modes de passage des paramŁtres . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 30
5 Les tableaux 33
6 Etude de quelques algorithmes sur les tableaux 35
3
4 TABLE DES MATI¨RES
7 La rØcursivitØ 37
8 Etude de quelques tris 39
9 Les structures 41
Chapitre 1
Introduction
1.1 Notion d’algorithme
L’algorithmiqueestunenotionancienne(apparuebienavantlespremiersordinateurs)quipeutsedØ(cid:28)nir
comme
(cid:16)une mØthode de rØsolution d’un problŁme sous la forme d’une suite d’opØrations ØlØmentaires
obØissant (cid:224) un encha(cid:238)nement dØterminØ.(cid:17)
ConsidØrons par exemple le problŁme suivant :
Plusieurs dossiers, classØs par ordre alphabØtique sur le nom, sont empilØs sur une table. Il
s’agit de dØterminer si une personne de nom X a bien un dossier (cid:224) son nom dans la pile.
Avant de chercher (cid:224) rØsoudre ce problŁme, on commence par le spØci(cid:28)er plus prØcisØment. Pour cel(cid:224), on
identi(cid:28)e :
(cid:21) les donnØes du problŁme (ce qu’on a en entrØe avant de commencer la rØsolution);
(cid:21) les rØsultats (ce qu’on fournit en sortie (cid:224) la (cid:28)n de la rØsolution);
(cid:21) les Øventuelles prØconditions sur les donnØes (des informations sur la nature des donnØes en entrØe);
(cid:21) les postconditions (une relation dØ(cid:28)nissant ce qu’on doit fournir en sortie en fonction de ce qu’on a en
entrØe).
Pour notre problŁme de recherche de dossier, on peut dØ(cid:28)nir la spØci(cid:28)cation suivante :
Algorithme : Recherche linØaire
EntrØes :
Une pile de dossiers P
Un nom X
Sorties :
Une rØponse R
PrØcondition :
Les dossiers de P sont empilØs par ordre alphabØtique sur le nom, le dossier comportant le
plus petit nom se trouvant au sommet de la pile.
Postcondition :
Si P contient un dossier au nom de X alors R doit Œtre Øgal (cid:224) oui sinon R doit Œtre Øgal (cid:224) non
On peut maintenant chercher une mØthode pour rØsoudre ce problŁme. Une premiŁre solution consiste
(cid:224) regarder successivement chaque dossier de la pile de fa(cid:231)on linØaire, (cid:224) partir du dossier se trouvant
au sommet de la pile, jusqu’(cid:224) trouver soit le dossier ayant pour nom X, soit un dossier ayant un nom
supØrieur (cid:224) X (auquel cas X n’a pas de dossier). L’algorithme correspondant peut s’exprimer de la fa(cid:231)on
suivante :
5
6 CHAPITRE 1. INTRODUCTION
dØbut
tant que la pile de dossiers P n’est pas vide
et le nom du dossier au sommet de P est infØrieur (cid:224) X faire
Prendre le dossier au sommet de P
Le poser (cid:224) cotØ de P
(cid:28)ntq
si P est vide ou le nom du dossier au sommet de P est di(cid:27)Ørent de X alors
R← non
sinon
R← oui
(cid:28)nsi
(cid:28)n
La nature des opØrations ØlØmentaires utilisØes pour rØsoudre le problŁme dØpend des capacitØs de la
personne (ou machine) qui va exØcuter l’algorithme.
Ici, on suppose que l’algorithme s’adresse (cid:224) une personne capable d’e(cid:27)ectuer les opØrations suivantes :
(cid:21) comparer (selon l’ordre alphabØtique) le nom du dossier au sommet de la pile avec X,
(cid:21) prendre le dossier au sommet de la pile,
(cid:21) poser un dossier (cid:224) cotØ de la pile,
(cid:21) regarder si la pile de dossiers est vide.
Cet algorithme introduit 3 types d’encha(cid:238)nement d’opØrations.
1. L’encha(cid:238)nement en sØquence consiste (cid:224) e(cid:27)ectuer les opØrations en sØquence les unes (cid:224) la suite des
autres. Par exemple, les lignes 4 et 5 s’encha(cid:238)nent en sØquence et, par consØquent, l’opØration
ØlØmentaire de la ligne 5 n’est commencØe qu’une fois que celle de la ligne 4 est terminØe.
2. L’encha(cid:238)nement alternatif consiste (cid:224) e(cid:27)ectuer alternativement soit une premiŁre suite d’opØrations,
soit une autre, en fonction d’une condition. Par exemple, en fonction de la condition de la ligne 7,
on e(cid:27)ectuera alternativement l’opØration ØlØmentaire de la ligne 8, ou celle de la ligne 10.
3. L’encha(cid:238)nementrØpØtitifconsiste(cid:224)e(cid:27)ectuerplusieursfoisunemŒmesuited’opØrationsØlØmentaires
tantqu’uneconditiondonnØeestvØri(cid:28)Øe.Parexemple,lesopØrationsdeslignes4et5sontrØpØtØes
tant que les deux conditions des lignes 2 et 3 sont vØri(cid:28)Øes.
Notons en(cid:28)n que cet algorithme termine, c’est (cid:224) dire qu’il s’exØcute en un temps (cid:28)ni. En e(cid:27)et, si la pile
contient n dossiers, les opØrations des lignes 4 et 5 seront exØcutØes au plus n fois : (cid:224) chaque fois, un
dossier est enlevØ de la pile; au bout de n fois, la pile est vide et la condition de la ligne 1 n’est plus
vØri(cid:28)Øe.
L’algorithmederecherchesØquentiellepermete(cid:27)ectivementderØsoudrenotreproblŁme.Ilestcependant
relativement ine(cid:30)cace : si la pile contient 1000 dossiers, il faudra en moyenne regarder le nom de 500
dossiers avant de pouvoir rØsoudre le problŁme, et dans le pire des cas, il faudra en regarder 1000.
De fait, une personne sensØe se trouvant face (cid:224) une pile de 1000 dossiers triØs par ordre alphabØtique ne
regardera pas chaque dossier linØairement, du premier au dernier, mais partagera la pile de dossiers en 2
pilesdetaillescomparableset,enfonctiondunomdudossierausommetdeladeuxiŁmepile,continuerasa
recherche soit dans la premiŁre pile, soit dans la seconde. Elle rØpŁtera ainsi ce processus (cid:16)dichotomique(cid:17)
jusqu’(cid:224) trouver le bon dossier ou bien jusqu’(cid:224) ce que la pile soit vide. L’algorithme correspondant peut
Œtre formulØ de la fa(cid:231)on suivante :
1.2. INTRODUCTION (cid:192) LA STRUCTURE D’UN ORDINATEUR 7
dØbut
tant que la pile de dossiers P n’est pas vide
et le nom du dossier au sommet de P est di(cid:27)Ørent de X faire
Couper la pile de dossiers P en 2 parties
(On appellera Psup la moitiØ supØrieure, et Pinf la moitiØ infØrieure)
si le nom du dossier au sommet de Pinf =X alors
Ne garder que le premier dossier de Pinf dans P
sinon si le nom du dossier au sommet de Pinf >X alors
Enlever de P tous les dossiers de Pinf
sinon
Enlever de P le premier dossier de Pinf
Enlever de P tous les dossiers de Psup
(cid:28)nsi
(cid:28)ntq
si P est vide alors
R← non
sinon
R← oui
(cid:28)nsi
(cid:28)n
Ce deuxiŁme algorithme, plus compliquØ dans son ØnoncØ que le premier est nØanmoins nettement plus
e(cid:30)cace. En e(cid:27)et, si la pile contient 1000 dossiers, on la sØparera en 2 piles de 500 dossiers puis une des
2 piles de 500 dossiers sera sØparØe en 2 piles de 255 dossiers, ... de telle sorte qu’en rØpØtant (au plus)
10 fois ce processus dichotomique, soit on aura trouvØ le dossier, soit la pile sera vide. Ainsi, alors que
l’algorithme de recherche sØquentiel demandera en moyenne de consulter 500 dossiers, celui de recherche
dichotomique ne demandera que 10 consultations (dans le pire des cas).
Ce premier exemple permet d’introduire un point fondamental de l’algorithmique, (cid:224) savoir la complexitØ.
En e(cid:27)et, Øtant donnØ un mŒme problŁme, il existe gØnØralement plusieurs algorithmes le rØsolvant. Ces
algorithmes seront notamment comparØs sur leur complexitØ en temps, c’est (cid:224) dire sur le nombre d’opØ-
rations ØlØmentaires qui devront Œtre e(cid:27)ectuØes pour rØsoudre un mŒme problŁme. Cette complexitØ
est calculØe (cid:16)approximativement(cid:17) dans le sens oø l’on donnera simplement un ordre de grandeur : sur
l’exemple prØcØdent on dira que l’algorithme de recherche linØaire est d’ordre linØaire, notØ O(n), ce qui
signi(cid:28)e que si l’on a n dossiers il faudra faire de l’ordre de n opØrations, tandis que l’algorithme de re-
cherche dichotomique est d’ordre logarithmique, notØ O(log (n)), ce qui signi(cid:28)e que si l’on a n dossiers
2
il faudra faire de l’ordre de log (n) opØrations.
2
1.2 Introduction (cid:224) la structure d’un ordinateur
Dans le contexte de ce cours, un algorithme est con(cid:231)u pour Œtre exØcutØ par un ordinateur. La notion
d’opØration ØlØmentaire dØpend donc des capacitØs d’un ordinateur. De fa(cid:231)on trŁs schØmatique, un ordi-
nateur est composØ des ØlØments suivants :
(cid:21) une mØmoire, chargØe de conserver l’information;
La mØmoire est composØe d’une suite d’informations ØlØmentaires appelØes bit. Un bit peut prendre
deux valeurs (gØnØralement symbolisØes par 0 et 1). Une suite de 8 bits forme un octet. Chaque octet
a une adresse dans la mØmoire permettant d’y accØder.
(cid:21) une unitØ centrale (CPU), chargØe de traiter l’information;
L’unitØcentraleestcapabled’exØcuterunnombre(cid:28)ni(ettrŁslimitØ)d’instructionssimples.L’ensemble
des instructions que l’unitØ centrale est capable d’exØcuter forme le langage machine.
(cid:21) plusieurs unitØs d’entrØe/sortie, chargØes d’Øchanger des informations avec l’environnement extØrieur
(le clavier, la souris, l’Øcran, ...);
(cid:21) unbus,chargØdetransfØrerl’informationentrelamØmoire,lesunitØsd’entrØe/sortieetl’unitØcentrale.
8 CHAPITRE 1. INTRODUCTION
1.3 DØmarche pour la rØsolution d’un problŁme
Pour rØsoudre un problŁme (cid:224) l’aide d’un ordinateur, il est assez vite apparu indispensable d’ajouter des
niveauxdedescriptionetd’abstractionentrel’homme,quiposeleproblŁme,etlamachine,quiestchargØe
de le rØsoudre. En e(cid:27)et, l’homme dØ(cid:28)nit le problŁme en langue naturelle (par exemple en fran(cid:231)ais), de
fa(cid:231)on informelle et souvent ambig(cid:252)e et incomplŁte. A l’autre extrØmitØ du processus, un ordinateur n’est
capabled’exØcuterquedesinstructionsdetrŁsbasniveau,oøl’informationestcodØesouslaformed’une
suite de 0 et de 1.
Du problŁme (cid:224) la spØci(cid:28)cation formelle
A partir de la description informelle, ambig(cid:252)e et incomplŁte du problŁme, l’analyste Ølabore une spØci-
(cid:28)cation formelle, qui dØcrit de fa(cid:231)on non ambig(cid:252)e et (si possible) complŁte et correcte ce que doit faire
le programme, c’est (cid:224) dire le (cid:16)quoi(cid:17). Cette description est faite indØpendemment d’une solution. Il s’agit
notamment de prØciser
(cid:21) les paramŁtres en entrØe, c’est (cid:224) dire la nature des questions ou donnØes du problŁme,
(cid:21) les paramŁtres en sortie, c’est (cid:224) dire la nature des solutions ou rØsultats au problŁme,
(cid:21) les prØconditions, c’est (cid:224) dire les conditions portant sur les paramŁtres en entrØe sous lesquelles le
problŁme est dØ(cid:28)ni,
(cid:21) larelationentrelesparamŁtresenentrØeetlesparamŁtresensortie,c’est(cid:224)direlavaleurdesparamŁtres
en sortie en fonction de celle des paramŁtres en entrØe,
(cid:21) les contraintes (cid:224) respecter pour la rØsolution du problŁme (notamment les contraintes de ressources).
De la spØci(cid:28)cation formelle (cid:224) l’algorithme
A partir de la spØci(cid:28)cation formelle, l’analyste/programmeur Ølabore un algorithme, qui spØci(cid:28)e le (cid:16)com-
ment(cid:17), c’est (cid:224) dire l’encha(cid:238)nement d’opØrations ØlØmentaires (cid:224) e(cid:27)ectuer pour rØsoudre le problŁme.
Un algorithme est gØnØralement ØlaborØ selon une dØmarche descendante, qui consiste (cid:224) dØcomposer le
problŁmeensous-problŁmes,chaquesous-problŁmedevantŒtredenouveauclairementspØci(cid:28)ØpuisrØsolu.
Cette dØcomposition permet d’aborder le problŁme progressivement en crØant des niveaux de description
de plus en plus dØtaillØs. Chacun des sous-problŁmes sera d’autant plus comprØhensible que dans sa
description il n’y a que quelques idØes simples. En gØnØral, la taille d’un algorithme ne doit pas dØpasser
une vingtaine de lignes.
VØri(cid:28)cation de l’algorithme
Une fois con(cid:231)u, un algorithme doit Œtre validØ. Il s’agit de vØri(cid:28)er que l’algorithme rØpond e(cid:27)ectivement
au problŁme spØci(cid:28)Ø, et plus particuliŁrement qu’il est
(cid:21) correct,c’est-(cid:224)-direquelesvaleursdesparamŁtresdesortiecalculØesparl’algorithmesonte(cid:27)ectivement
celles que l’on souhaitait calculer;
(cid:21) complet, c’est-(cid:224)-dire que les bonnes valeurs des paramŁtres de sortie sont trouvØes pour toutes les
valeurs possibles des paramŁtres en entrØe (dans les limites spØci(cid:28)Øes par les prØconditions);
(cid:21) (cid:28)ni, c’est-(cid:224)-dire que le nombre d’opØrations ØlØmentaires (cid:224) e(cid:27)ectuer pour rØsoudre le problŁme est (cid:28)ni,
autrement dit, que l’algorithme ne (cid:16)boucle(cid:17) pas indØ(cid:28)niment sur une sØrie d’instructions.
Cette vØri(cid:28)cation peut Œtre e(cid:27)ectuØe de fa(cid:231)on thØorique par une preuve. Elle doit gØnØralement Œtre
validØe expØrimentalement par des tests, c’est (cid:224) dire une simulation de l’exØcution de l’algorithme sur
un certain nombre de donnØes. Ces donnØes utilisØes pour tester la solution sont appelØes jeux d’essai.
Elles doivent Œtre les plus complŁtes possibles, de fa(cid:231)on (cid:224) tester l’algorithme sur tous les cas possibles
d’utilisation.
Il s’agit par ailleurs d’Øvaluer la complexitØ en temps de l’algorithme, c’est (cid:224) dire un ordre de grandeur
du nombre d’opØrations ØlØmentaires qui devront Œtre e(cid:27)ectuØes en fonction des valeurs des paramŁtres
en entrØe. En(cid:28)n, il faut Øgalement Øvaluer la complexitØ en espace de l’algorithme, c’est (cid:224) dire la taille
mØmoire nØcessaire (cid:224) l’exØcution de l’algorithme.
1.3. D(cid:201)MARCHE POUR LA R(cid:201)SOLUTION D’UN PROBL¨ME 9
De l’algorithme au programme
L’algorithme est ensuite codØ par le programmeur dans un langage de programmation. On distingue
usuellement 3 styles de langages de programmation, correspondant (cid:224) 3 paradigmes de programmation :
(cid:21) les langages impØratifs (par exemple C, Ada, Cobol, Fortran, Pascal), oø les opØrations ØlØmentaires
sont des a(cid:27)ectations et appels de procØdures;
(cid:21) les langages fonctionnels (par exemple Lisp, Scheme, Haskell, CAML), oø les opØrations ØlØmentaires
sont des appels de fonctions;
(cid:21) leslangageslogiques(parexempleProlog),oølesopØrationsØlØmentairessontdesa(cid:30)rmationslogiques.
Dans ces 3 catØgories de langages de programmation, les programmes sont essentiellement structurØs en
termes de dØcomposition fonctionnelle et de traitements. Il existe un quatriŁme paradigme de program-
mation, orthogonal aux 3 premiers qui consiste (cid:224) structurer les programmes en termes de donnØes : la
programmation orientØe objet. Ainsi, il existe des langages impØratifs orientØs objet (par exemple C++,
Java,Ei(cid:27)el),deslangagesfonctionnelsorientØsobjet(parexempleClos,Smalltalk,Loops)etdeslangages
logiques orientØs objet (par exemple L&O, Login, Life).
Les opØrations ØlØmentaires utilisØes pour coder un algorithme dØpendent du langage de programmation
choisi. NØanmoins, tous ces langages permettent de coder facilement les di(cid:27)Ørents types d’encha(cid:238)nements
(en sØquence, alternatif et rØpØtitif) apparaissant dans un algorithme. La structuration et la gestion des
donnØes varie aussi d’un langage (cid:224) l’autre. Il est alors nØcessaire d’adapter en consØquence l’algorithme
au moment du codage.
Du programme au code exØcutable
Le code Øcrit dans un langage de programmation, appelØ le code source, est ensuite traduit par un
compilateur ou un interprØteur en un code en langage machine, appelØ le code objet et exØcutable par
l’ordinateur. Un compilateur traduit la totalitØ du programme source pour gØnØrer un code objet qui
sera ensuite exØcutØ, tandis qu’un interprØteur traduit une par une les instructions du code source et les
exØcuteaufuret(cid:224)mesuredelatraduction.Cettephasedecompilationoud’interprØtationestentiŁrement
automatique et est e(cid:27)ectuØe par un programme. Vous en apprendrez plus sur ce sujet (cid:224) l’occasion du
cours de thØorie des langages, en deuxiŁme annØe.
10 CHAPITRE 1. INTRODUCTION