Cours

Algorithmique
& Structures de donnes I

SUPPORT DE COURS
1ERE ANNEE LICENCE TECHNOLOGIES DE LINFORMATIQUE
1ERE ANNEE PREPARATOIRE I NTEGRE
3EME ANNEE GENIE INFORMATIQUE CYCLE INGENIEUR
Adel DAHMANE
adeldahmane.net@gmail.com
Hind ELOUEDI
h_elouedi@yahoo.fr
Walid MELIANI
walid.meliani@isetso.rnu.tn
Notions abordes
LES ELEMENTS DE BASE D'UN ALGORITHME
Les structures de donnes simples
Les instructions lmentaires
LES STRUCTURES DE CONTROLES
Les structures conditionnelles (de choix)
Les structures itratives (les boucles)
LES STRUCTURES DE DONNEES COMPOSEES
Le type Tableau
Le type Chane de caractre
Le type Structure (Enregistrement)
LES SOUS PROGRAMMES : LES FONCTIONS ET LES PROCEDURES
LA RECURSIVITE
LES ALGORITHMES DE RECHERCHE : SEQUENTIELLE ET DICHOTOMIQUE
LES ALGORITHMES DE TRI : TRI A BULLES, TRI PAR SELECTION, TRI INSERTION, ...
Table des matires
CHAPITRE 1: LES ELEMENTS DE BASE D'UN ALGORITHME
CHAPITRE 2: LES STRUCTURES CONDITIONNELLES
CHAPITRE 3: LES STRUCTURES ITERATIVES
CHAPITRE 4: STRUCTURES DE DONNEES COMPOSEES
2
UVT
Auteurs : A. DAHMANE, H. ELOUEDI & W. MELIANI | Algorithmique & Structures de donnes I
2004
CHAPITRE 5: LES SOUS PROGRAMMES
CHAPITRE 6: LA RECURSIVITE
CHAPITRE 7: LES ALGORITHMES DE RECHERCHE
3
UVT
2004
CHAPITRE
LES ELEMENTS DE BASE
DUN ALGORITHME 1
OBJECTIF
Construire des algorithmes structures simples.
ELEMENTS DE CONTENU
1) NOTION DOBJET ALGORITHMIQUE .......................................................................................... 5

1.1. DEFINITION .................................................................................................................................. 5
1.2. CARACTERISATION DUN OBJET ALGORITHMIQUE............................................................................ 5
2) STRUCTURE GENERALE DUN ALGORITHME .......................................................................... 6
2.1. PARTIE DECLARATIVE ................................................................................................................... 7
2.2. CORPS DE LALGORITHME ............................................................................................................. 8
3) LES STRUCTURES DE DONNEES SIMPLES .............................................................................. 8
3.1. LES TYPES NUMERIQUES .............................................................................................................. 8
3.2. LE TYPE CARACTERE .................................................................................................................... 9
3.3. LE TYPE BOOLEEN OU LOGIQUE .................................................................................................. 10
4) LES INSTRUCTIONS ELEMENTAIRES ...................................................................................... 10
4.1. LINSTRUCTION DAFFECTATION .................................................................................................. 10
4.2. LINSTRUCTION DECRITURE ....................................................................................................... 11
4.3. LINSTRUCTION DE LECTURE ....................................................................................................... 12
FIGURES
FIGURE 1 : STRUCTURE GENERALE DUN ALGORITHME ................................................................................. 6

FIGURE 2 : DEFINITION DE CONSTANTE ....................................................................................................... 7
FIGURE 3 : DEFINITION DE TYPE .................................................................................................................. 7
FIGURE 4 : DEFINITION DE VARIABLE ........................................................................................................... 7
FIGURE 5 : LINSTRUCTION DAFFECTATION ............................................................................................... 11
FIGURE 6 : LINSTRUCTION DECRITURE ..................................................................................................... 11
FIGURE 7 : LINSTRUCTION DE LECTURE .................................................................................................... 12
4
UVT
2004
Chapitre 1
Elments de base d'un algorithme
1) NOTION DOBJET ALGORITHMIQUE
1.1 DEFINITION
Pour chaque algorithme, on a besoin de donnes pour fournir des rsultats. Donnes et
rsultats sont appels des objets algorithmiques. On distingue :
Les objets en entre (saisis ou mmoriss) : ce sont les donnes fournies l'algorithme.
Les objets en sortie : ce sont les rsultats produits par l'algorithme.
Les objets internes ou intermdiaires (locaux) : ce sont les objets de manuvre de
l'algorithme servant aux manipulations internes (exp : compteurs, objets intermdiaires de
stockage).
Exemple : On se propose de permuter le contenu de deux objets A et B. Pour ce faire, on aura

besoin des objets A et B en entre et d'un troisime objet intermdiaire C puis on procdera
comme suit :
On met le contenu de A dans C.
On met le contenu de B dans A.
On met le contenu de C dans B.
Les objets A et B serviront aussi pour objets de sortie.
1.2. CARACTERISATION DUN OBJET ALGORITHMIQUE
Les objets algorithmiques, traits par lordinateur, sont stocks dans des cases mmoires dont
la gestion est prise en charge par lordinateur. En mmoire, les cases sont reconnues laide
de leurs adresses, on parle dadresse mmoire. Pour dfinir un objet algorithmique, on doit
prciser son nom, son sens, son type, son utilisation et sa nature.
a) NOM : Il sert dsigner l'objet dans l'algorithme, il est reprsent par une chane de
caractres alphanumriques qui commence obligatoirement par un caractre alphabtique.
Dans la mesure du possible, ce nom doit tre significatif, on l'appelle aussi identificateur.
NB : l'identificateur d'un objet algorithmique ne doit pas contenir le caractre Espace.
b) SENS : C'est la signification d'un objet, son rle, son utilisation dans le problme.
Exp : Soit Masse_Corps la masse d'un corps en kilogrammes.
c) TYPE : Le type d'un objet caractrise les valeurs que peut prendre cet objet. On distingue les
types simples et les types structurs (composs).
Un objet de type simple contient une seule information, tandis qu'un objet de type structur
contient une collection d'informations rparties en plusieurs champs, accessibles
individuellement ou collectivement.
Un objet de type structur est homogne si toutes ses informations sont de mme type et
htrogne dans le cas contraire.
5
UVT
2004
Chapitre 1
Exemples :
Type simple : Entier, Rel, Caractre,...
Type structur homogne : Un tableau d'entiers.
Type structur htrogne : Un enregistrement Etudiant contenant :
- Le numro de la carte d'tudiant de type entier.
- Le nom et le prnom de type chane de caractres.
d) UTILISATION : Il s'agit de prciser si un objet est en entre (E), en sortie (S) ou interne (I).
e) NATURE : Il s'agit de prciser si un objet est une constante (Const) ou une variable (Var).
Exemple : On se propose de reprsenter les objets algorithmiques utiliss dans un problme de

rsolution d'une quation du premier degr une seule inconnue. Soit l'quation de la forme:
ax + b = 0. Pour ce faire, on va dresser le tableau suivant :
Nom Sens Type Utilisation Nature

a Premier coefficient de l'quation Rel (non nul) E Var
b Deuxime coefficient de l'quation Rel E Var
x Solution de l'quation Rel S Var
2) STRUCTURE GENERALE DUN ALGORITHME
Un algorithme est une suite finie et ordonne doprations lmentaires (instructions ou

actions), crites dans un langage de programmation abstrait non comprhensible par la
machine, et constituant un schma de calcul ou de rsolution informatique dun problme. Il
devrait tre exprim par la suite dans un langage de programmation concret (volu), traduit en
langage machine puis excut afin daboutir aux rsultats effectifs.
Figure 1 : Structure gnrale dun algorithme
-- Auteur : Nom de lauteur

-- Date dcriture : Date dcriture de lalgorithme
-- Fonction : Ce que doit faire lalgorithme En-tte
ALGORITHMENom_algorithme
DEFCONST
Liste des constantes avec leurs valeurs
DEFTYPE Partie
Liste des types personnaliss (tableau, structure) Dclarative
DEFVAR
Liste des variables avec leurs types
DEBUT
Instruction 1
Instruction 2 Corps de
... lalgorithme
Instruction n
FIN
6
UVT
2004
Chapitre 1
2.1. PARTIE DECLARATIVE
Avant d'utiliser n'importe quel objet algorithmique, il faut le dclarer au niveau de la partie
dclarative de l'algorithme. Ces objets peuvent tre de deux natures savoir : constante ou
variable. Dans ce qui suit, on va dcrire la partie dclarative relative un algorithme qui est
compose de trois parties pas ncessairement toutes prsentes :
a) DEFINITION DES CONSTANTES : Il s'agit de la premire rubrique de la partie dclarative qui
sert dfinir les constantes utilises dans l'algorithme. Une constante est une donne dont
la valeur reste fixe durant toute la dure de lexcution dun algorithme.
Figure 2 : Dfinition de constante
DefConst
identificateur (Type) = valeur
Exemple :
a (Entier) = 5
b (Rel) = 2.5
b) DEFINITION DES TYPES : C'est la deuxime rubrique de la partie dclarative qui sert dfinir
les types non standards (non prdfinis).
Figure 3 : Dfinition de type
DefType
Nom_Type = Dfinition de type
Exemple :
Tab = Tableau[1..10] de Entier -- Dclaration de type tableau d'entiers
Indice = 1..10 -- Dclaration de type intervalle
Etudiant =Structure -- Dclaration de type enregistrement
NCE : Entier
Nom : Chane(15)
Prnom : Chane(15)
Fin Structure
c) DEFINITION DES VARIABLES : C'est la troisime rubrique de la partie dclarative qui sert
dclarer les diffrentes variables utilises dans l'algorithme.
Figure 4 : Dfinition de variable
DefVar
identificateur (Type) -- Commentaire
Exemples :
DefVar
x (Entier) -- Dividende.
y (Entier) -- Diviseur diffrent de zro.
z (Rel) -- Quotient.
r (Entier) -- Reste de la division.
7
UVT
2004
Chapitre 1
2.2. CORPS DE LALGORITHME

Cette partie de lalgorithme contient lensemble des instructions applicables sur lensemble des objets
algorithmiques dj dclars au niveau de la partie prcdente (dclarative). Ces instructions se divisent
en essentiellement en trois catgories :
Les instructions simples : Entre de donnes, sortie de rsultats, affectation.
Les structures dcisionnelles (conditionnelles ou alternatives) : Ce sont des structures de contrle
permettant de choisir entre les traitements.
Les structures itratives (rptitives) : Ce sont des structures de contrle permettant de rpter un
ensemble de traitement autant de fois quil est ncessaire.
3) LES STRUCTURES DE DONNEES SIMPLES
3.1. LES TYPES NUMERIQUES

Ils reprsentent les types Entier et Rel. En algorithmique, le type Entier reprsente lensemble Z et le
type Rel lensemble R. Les entiers varient entre 32767 et 32768 et les rels entre 1E38 1E38.
On peut dfinir ainsi des constantes numriques de type Entier ou Rel (5, 100 ou 30.5, 50.9).ou bien
des variables numriques se rapportant ces deux types. En effet, ces variables sont des objets dont le
contenu est modifiable au cours dune excution. Les deux types sont manipuls travers les oprations
arithmtiques suivantes :
Laddition : note +, assure la somme de valeurs numriques.
La soustraction : note -, assure la diffrence entre des valeurs numriques.
La multiplication : note *, assure le produit entre des valeurs numriques.
La division : note /, assure la division relle des valeurs numriques.
La division entire : note DIV, elle retourne la partie entire dune division euclidienne (entire).
Le modulo : note MOD, elle retourne le reste de la division entire.
La puissance : note ^ ou **, elle assure la puissance de valeurs numriques.
La priorit dfinie pour ces oprations est la suivante :

1- () : les valeurs places entre parenthses sont toujours values en premier.
2- ** ou ^ : le calcul de puissance seffectue en deuxime.
3- * / : la multiplication et la division seffectuent en troisime
4- DIV : la division entire seffectue en quatrime.
5- MOD : le modulo est calcul en cinquime.
6- + - : laddition et la soustraction seffectuent en dernier
Les comparaisons se font laide des oprateurs de comparaison qui sont : , =, <, >, ,
Le tableau suivant prsente les fonctions arithmtiques standards les plus utilises :
Fonction Role Type de x Type de rsultat Exemple
ABS(x) Retourne la valeur absolue de x Entier ou Rel Mme type que x
Arrondi(x) Retourne l'entier le plus proche de x Rel Entier
Carre(x) Retourne le carr de x Entier ou Rel Mme type que x
Racine(x) Retourne la racine carr de x (x >0, sinon erreur) Entier ou Rel Rel
Tronc(x) Retourne seulement la partie entire de x Rel Entier
Alea(x) Retourne un entier dans [0, x-1] Entier (>0) Entier
8
UVT
2004
Chapitre 1
3.2. LE TYPE CARACTERE

Les variables Caractre contiennent un caractre et un seul, un caractre est stock sous la forme d'un
nombre de 16 bits (2 octets) non sign dont les valeurs sont comprises entre 0 et 65 535. Chaque
nombre reprsente un seul caractre Unicode.
L'Unicode est donc un codage de caractres sur 16 bits qui contient tous les caractres d'usage courant
dans les langues principales du monde. Les premiers 128 codes (0..127) Unicode correspondent aux
lettres et aux symboles du clavier amricain standard.
Ce sont les mmes que ceux dfinis par le jeu de caractres ASCII (Americain Standard Code for
Information Interchange:ancien codage sur un octet). Les 128 codes suivants (128..255) reprsentent les
caractres spciaux, tels que les lettres de l'alphabet latin, les accents, les symboles montaires et les
fractions. Les codes restants sont utiliss pour des symboles, y compris les caractres textuels
mondiaux, les signes diacritiques, ainsi que les symboles mathmatiques et techniques.
Les oprations prdfinies relatives au type caractre sont les suivantes:

ASC(c) : renvoie le code ASCII/Unicode du caractre c.
CHR(n) : renvoie le caractre du code ASCII/Unicoden.
SUCC(c) : renvoie le caractre successeur de c.
PRED(c) : renvoie le caractre prdcesseur de c.
MAJUS(c) : convertit le caractre c en majuscule.
Voici un extrait de la table Unicode (codes ASCII standards):
Exemples: ASC("7")=55, ASC("'")=39, ASC("\")=92, CHR(55)="7",CHR(39)="'", CHR(92)="\"
NB: Le petit carr indique un caractre non imprimable (non affichable), certains caractres sont des
caractres de contrle comme le numro 9 qui correspondant tabulation, le numro 13 qui correspond
au retour la ligne.
9
UVT
2004
Chapitre 1
3.3. LE TYPE BOOLEEN OU LOGIQUE

Cest une information qui peut avoir que la valeur Vrai ou Faux. Les oprateurs boolens sont :
Unaire : NON (ngation)
Binaire : ET (conjonction logique) OU (disjonction) OUex (disjonction exclusive)
La priorit est dfinie comme suit : NON, ET, OU/OUex (de mme priorit)
Tables de vrit : Soient P et Q deux variables boolennes (logiques)
NON ET OU OUex
P NON P P Q P ET Q P Q P OU Q P Q P OUex Q
V F V V V V V V V V F
F V V F F V F V V F V
F V F F V V F V V
F F F F F F F F F
3.4. LE TYPE SCALAIRE ENUMERE

Le type scalaire par numration dfinit un ensemble ordonn de valeurs dsignes par des
identificateurs. Exemple : SEMAINE = {lundi, mardi, mercredi, jeudi, vendredi, samedi, dimanche}
NB : Une variable jour de type Semaine peut prendre comme valeur : lundi, mardi, mercredi, jeudi,
vendredi, samedi ou dimanche. Les oprateurs applicables ces valeurs sont : les oprateurs de
relations et les oprateurs PRED, SUCC et ORD.
3.5. LE TYPE INTERVALLE

Le type intervalle possde les proprits dun type scalaire discret ordonn (Entier, Caractre et Scalaire
numr). La dfinition dun intervalle est dcrite par la donne de deux constantes Borne Infrieure et
Borne Suprieure appartenant un type scalaire discret ordonn et tel que Borne InfrieureBorne
Suprieure.
Exemples : mois : 1..12 //cette dclaration est beaucoup plus prcise que mois : Entier
Lettre_Majuscule = "A".."Z" // c : Lettre_Majuscule
4) LES INSTRUCTIONS ELEMENTAIRES
4.1. LINSTRUCTION DAFFECTATION
Il s'agit d'une instruction de base dans un algorithme. Pour pouvoir utiliser un objet dans un
algorithme, il faut lui attribuer un nom qui correspond une case en mmoire : C'est l'action de
dclaration d'un objet. Les dclarations seront toujours places avant le dbut de l'algorithme.
Aprs avoir dclar un objet, il faut pouvoir y ranger une valeur : C'est l'action d'affectation
note par : "". Deux notions s'avrent importantes dfinir ce niveau et qui sont les notions
de valeur et de variable.
Notion de valeur : C'est une quantit qui a une existence propre et qui est attribuable quelque chose.
Notion de variable : Une variable est caractrise par son nom, son sens, son type et son utilisation. On utilise
des variables dans les traitements algorithmiques et ceci en leur affectant des valeurs ayant pour type le mme
que celui de la variable.
10
UVT
2004
Chapitre 1
Ainsi l'affectation se dfinit comme tant l'attribution d'une valeur une variable.
Figure 5 : Linstruction daffectation
nom_variable expression
le nom d'une variable la valeur affecter
destine Symbole la variable
recevoir une valeur d'affecta
tion a un double rle :
On peut alors dire qu'une instruction d'affectation
Elle dtermine la valeur de l'expression (expression) situe droite du symbole .
Elle range le rsultat dans la variable (nom_variable) situe gauche.
Exemple : Le tableau ci-contre montre les valeurs

A B
de A et B aprs l'excution de chacune des
instructions mentionnes.
Remarque : Aprs l'excution de (1) la variable (1) A1 1 -
B n'avait pas encore reu de valeur. On dit (2) BA+3 1 4
qu'une telle variable est Indfinie ou Non (3) A3 3 4
dfinie.
Lorsqu'une variable apparat au niveau de la partie droite d'une affectation, c'est que l'on
suppose qu'elle contient une valeur. Cette valeur devra lui avoir t affecte : Il s'agit alors
de l'action d'initialisation.
Exemples :
A3 -- Initialisation.
B4 -- Initialisation.
CA*3+4B -- Affectation de la valeur d'une expression (ceci suppose l'valuation
-- de l'expression en respectant les rgles de priorit des oprateurs).
Remarques :
Tout objet utilis dans un algorithme doit tre dclar une et une seule fois.
L'action d'affectation pourra s'effectuer plusieurs fois dans l'algorithme, la valeur de l'objet sera
alors modifie chaque affectation.
4.2. LINSTRUCTION DECRITURE
Cette instruction est nomme aussi Sortie, elle permet de communiquer ou visualiser les
rsultats. La forme gnrale de l'instruction d'criture est la suivante :
Figure 6 : Linstruction dcriture
Ecrire (expression_1, expression_2, ..., expression_n)
Ce sont des noms des donnes qui sont sous forme de variables, constantes ou d'expressions
On peut aussi afficher des messages qui seront reprsentes entre guillemets.
11
UVT
2004
Chapitre 1
Exemple :
Algorithme Ecriture
DefConst
a (Entier) = 3 -- dclarer une constante a de type Entier (a=3)
DefVar
x, y, z (Entier) -- dclarer trois variables x, y et z de type Entier
Dbut
xa -- affecter la variable x la valeur de la constante a
y 15 -- affecter la variable y la valeur 15
zx+y -- affecter la variable z la somme de x et y
Ecrire (x, y) -- crire les valeurs de x et y sur la mme ligne
Ecrire ("la valeur de z est : ", z) -- crire la valeur de z sur la ligne suivante.
Fin
Cet algorithme (Ecriture) fournira ces rsultats : 3 15

la valeur de z est : 18
Remarque : les textes qui accompagnent les rsultats s'appellent des libells. Pour les obtenir, il
suffit de faire apparatre ces libells dans la liste des informations crire. Plus prcisment, ces
libells devront tre placs entre guillemets ("libell").
4.3. LINSTRUCTION DE LECTURE
Cette instruction est nomme aussi Entre, elle permet d'introduire une donne partir d'un
priphrique d'entre (le clavier par exemple) et de l'affecter une variable. La forme
gnrale de l'instruction de lecture est la suivante :
Figure 7 : Linstruction de lecture
Lire (nom_variable_1, nom_variable_2, ..., nom_variable_n)
les noms de variables destines ranger les valeurs prises sur le priphrique d'entre
Exemple : Cet algorithme permet de lire un nombre et d'crire son carr.
Algorithme Carr
DefVar
nombre, carr (Entier)
Dbut
Lire (nombre)
carr nombre * nombre
Ecrire ("Le carr de ", nombre, " est : ", carr)
Fin
Si on excute cet algorithme (Carr) en lui fournissant la valeur 5 comme donne, on obtiendra le
rsultat suivant : 5
Le carr de 5 est 25
Remarque :une squence de traitements est une suite d'instructions lmentaires excutes
squentiellement une seule fois.
12
UVT
2004
CHAPITRE
LES STRUCTURES
CONDITIONNELLES 2
OBJECTIF
Utiliser les structures dcisionnelles dans la construction des algorithmes.
ELEMENTS DE CONTENU
1) INTRODUCTION ...........................................................................................................14
1.1. EXEMPLE INTRODUCTIF .............................................................................................................. 14
1.2. DEFINITION DE CHOIX ................................................................................................................. 14
2) LES STRUCTURES CONDITIONNELLES SIMPLES ...................................................14

2.1. STRUCTURE CONDITIONNELLE A UN SEUL CHOIX .......................................................................... 14
2.2. STRUCTURE CONDITIONNELLE A DEUX CHOIX .............................................................................. 15
3) LES STRUCTURES CONDITIONNELLES GENERALISEES .......................................16

3.1. STRUCTURE CONDITIONNELLE IMBRIQUEE ................................................................................... 16
3.2. AUTRE FORME GENERALISEE (STRUCTURE SELON)...................................................................... 17
FIGURES
FIGURE 1 : STRUCTURE CONDITIONNELLE SIMPLE A UN SEUL CHOIX ........................................................... 15

FIGURE 2 : STRUCTURE CONDITIONNELLE SIMPLE A DEUX CHOIX ................................................................ 15
FIGURE 3 : STRUCTURES CONDITIONNELLES IMBRIQUEES .......................................................................... 16
FIGURE 4 : STRUCTURE GENERALISEE SELON ........................................................................................... 16
13
UVT
2004
Chapitre 2
Les Structures conditionnelles
1) INTRODUCTION
1.1. EXEMPLE INTRODUCTIF
Souvent, on est confront des situations o il faut faire un choix en se basant sur des
critres qui sont exprims par des conditions. Cette notion est exprime par les structures
dcisionnelles ou conditionnelles. Voici dans ce qui suit un exemple qui explique cette
notion.
Exemple :
On se propose de dterminer les diffrents rsultats relatifs aux moyennes des tudiants
dune institution. Pour ce faire, il faut avoir la moyenne dj calcule puis la faire passer
travers des filtres ou ce quon appelle tests ou encore conditions. Si elle vrifie lune des
conditions, la mention correspondante sera communique. Les filtres exprimer sont les
suivants :
Si (moyenne 0) et (moyenne < 10) Alors le rsultat est : Redouble.
Si (moyenne 10) et (moyenne < 12) Alors le rsultat est : Admis Passable.
Si (moyenne 12) et (moyenne < 14) Alors le rsultat est : Admis Assez Bien.
Si (moyenne 14) et (moyenne < 16) Alors le rsultat est : Admis Bien.
Si (moyenne 16) et (moyenne 20) Alors le rsultat est : Admis Trs Bien.
Si (moyenne > 20) ou (moyenne < 0) Alors le rsultat est : Moyenne invalide.
Lvaluation de chacune des conditions donne deux valeurs possibles, Vrai ou Faux, cest
une valeur logique. Si la condition a la valeur Vrai, le traitement qui suit est alors effectu.
1.2. DEFINITION DE CHOIX
On a vu, jusqu'ici, qu'on peut souvent rencontrer des situations qui ne peuvent pas tre
traites par les seules squences utilisant les instructions de base. En effet, on a besoin
parfois de choisir entre deux ou plusieurs traitements selon la ralisation ou non d'une
certaine condition, d'o la notion de traitement conditionnel. On peut distinguer trois
structures de traitement conditionnel :
Une structure conditionnelle simple : dans laquelle on a choisir entre deux traitements
au plus. On distingue deux structures conditionnelles simples :
Une structure conditionnelle un seul choix (structure simple rduite)
Une structure conditionnelle deux choix (structure simple complte)
Une structure conditionnelle plusieurs choix (structure gnralise): dans laquelle on a
la possibilit de choisir un traitement parmi plusieurs.
2) LES STRUCTURES CONDITIONNELLES SIMPLES
2.1. STRUCTURE CONDITIONNELLE A UN SEUL CHOIX
La structure conditionnelle un seul choix se prsente comme suit :
14
UVT
2004
Chapitre 2
Figure 1 : Structure conditionnelle simple un seul choix
SI (expression_logique) ALORS
Instruction 1
Instruction 2
...
Instruction n
FINSI
2.2. STRUCTURE CONDITIONNELLE A DEUX CHOIX
La structure conditionnelle deux choix se prsente comme suit :

Figure 2 : Structure conditionnelle simple deux choix
SI (expression_logique)
ALORS bloc d'instructions1
SINON bloc d'instructions2
FINSI
Remarque : Si l'expression logique mentionne aprs le mot Si a la valeur logique Vrai, on excute ce qui figure
aprs le mot Alors ; si l'expression logique a la valeur logique Faux, on excute ce qui figure aprs le mot Sinon.
Exemple 1:lalgorithme suivant permet de lire un nombre entier puis de vrifier s'il est pair ou impair.
Dclarer deux variables de type entier : une pour recevoir un nombre partir du clavier, l'autre
pour recevoir le reste de la division entire par 2.
Calculer, l'aide de la fonction Mod, le reste de la division entire du nombre par 2.
Tester pour voir si le reste est gal 0, dans ce cas le nombre est pair ; dans le cas contraire le
nombre est impair.
Algorithme Pair_Impair
DefVar
nombre, reste (Entier)
Dbut
Ecrire ("Donnez un nombre entier : ")
Lire (nombre)
reste nombre Mod 2
Si (reste = 0) -- ou bien Si (nombre Mod 2 = 0)
Alors Ecrire ("Le nombre ", nombre, " est pair")
Sinon Ecrire ("Le nombre ", nombre, " est impair")
FinSi
Fin
Exemple 2: Evaluation d'une expression logique (Prdicat).

Algorithme Prdicat
DefVar
Ok, V, F (Boolen) -- dclarer 3 variables de type logique
Dbut
V Vrai -- affecter V la valeur logique Vrai
F Faux -- affecter F la valeur logique Faux
Ok Non (V Ou V) Et ((F Et F) Ou (F OuNon V)) -- affecter Ok un prdicat
Si (Ok = Vrai) -- ou bien Si (Ok) -- Tester pour voir si Ok est vrai
Alors Ecrire ("OK = Vrai (True)") -- Attention !
Sinon Ecrire ("OK = Faux (False)") -- Ecrire ("OK = ", OK) incorrecte.
FinSi
Fin
15
UVT
2004
Chapitre 2
3) LES STRUCTURES CONDITIONNELLES GENERALISEES
3.1. STRUCTURES CONDITIONNELLESIMBRIQUEES
Les structures conditionnelles imbriques (ou emboites) se prsentent comme suit :

Figure 3 : Structures conditionnelles imbriques
SI (expression_logique1)
ALORS bloc d'instructions 1
SINONSI (expression_logique2)
ALORS bloc d'instructions 2
SINONSI ...
FINSI
Exemple : Calcul de remise

A partir d'un montant lu en donne, on dtermine un montant net par application d'une remise de :
5% si le montant est compris entre 2000 DT (inclus) et 5000 DT (inclus).
10% si le montant est suprieur ou gal 5000 DT.
Analyse :
Dclarer trois variables (Montant, Taux et Remise) de type numrique.
Lire le montant partir du clavier.
Tester pour voir si le montant introduit par l'utilisateur est infrieur ou gal 2000 D, dans ce cas
affecter Taux la valeur 0 ; dans le cas contraire tester pour voir si le montant est infrieur 5000
D. Si cette dernire condition est vrifie, affecter Taux la valeur 5 sinon 10.
Calculer le montant de remise
Affecter Montant le montant net.
Algorithme Calcul_remise_Version1
DefVar
Montant, Remise (Rel)
Taux (Entier)
Dbut
Ecrire ("Montant ? (en Dinars) :")
Lire (Montant)
Si (Montant 2000) --Si (Montant 2000)
Alors Taux 0 -- Alors Taux 0
SinonSi (Montant = 5000) -- SinonSi (Montant = 5000)
Alors Taux 5 -- Alors Taux 5
Sinon Taux 10 -- Sinon Taux 10
FinSi --FinSi
FinSi
Remise Montant * Taux / 100
Montant Montant Remise
Ecrire ("Montant Net :", Montant)
Fin
Remarque : Notez que beaucoup d'autres formulations sont possibles. Ainsi, par exemple, on peut
viter l'emploi de choix imbriqus en utilisant trois structures conditionnelles simples:
16
UVT
2004
Chapitre 2
Si (Montant 2000)
Alors Taux 0
FinSi
Si (Montant = 2000) Et (Montant = 5000)
Alors Taux 5
FinSi
Si (Montant 5000)
Alors Taux 10
FinSi
3.2. AUTRE FORME GENERALISEE (STRUCTURE SELON)

La structure conditionnelle Selon (ou Cas) est utilise pour slectionner une squence possible
d'instructions parmi plusieurs. Elle ressemble la structure Si...Alors...Sinon, mais elle est plus
efficace lorsqu'il s'agit de tester la mme variable plusieurs fois. Sa forme gnrale se prsente de
deux faons diffrentes :
Figure 4 :Structure gnralise Selon
SELONSlecteurFAIRE
Liste_valeurs1 : instructions excutes si Slecteur est inclus dans Liste_valeurs1
Liste_valeurs2 : instructions excutes si Slecteur est inclus dans Liste_valeurs2
...
Liste_valeursN : instructions excutes si Slecteur est inclus dans Liste_valeursN
[SINON : instructions excuter si rien ne correspond]
FINSELON
Slecteur : est un identificateur de variable ou une expression de type scalaire.

Liste_valeurs1..Liste_valeursN : ce sont des valeurs servant aux tests. Elles peuvent tre donnes sous
forme de constantes et/ou d'intervalles constants de type compatible avec le slecteur.
Liste_Valeurs1 (exemple1: 1..10 / exemple2: 1,3,5,7,9 / exemple3: 1..10, 20..30)
[...] : bloc facultatif
Remarque :
Si le contenu du slecteur mentionn aprs le mot Selon(Cas) correspond une valeur parmi les
listes des valeurs mentionnes aprs le mot Faire, on excute toutes les instructions qui suivent cette
valeur jusqu' la liste de valeurs suivante. Si rien ne correspond, on excute les instructions qui
figurent aprs le mot Sinon. Puis l'algorithme sort de la structure et continue l'excution aprs le mot
FinSelon (FinCas)
Exemple 1 : Cet algorithme permet de saisir une date sous la forme jj mm aa et d'afficher le nombre
de jours du mois mm et le nombre de jours qui restent pour la fin de ce mois.
Analyse :
Dclarer 5 variables de type entier :
3 variables (jj, mm et aa) pour recevoir la date.
1 variable (jtot) pour recevoir le nombre total de jours du mois mm.
1 variable (jreste) pour calculer le nombre de jours restant pour la fin du mois mm.
Lire la date sous la forme demande.
Slectionner le bon mois.
Dterminer les valeurs des variables jtot et jreste en tenant compte des annes bissextiles.Une
anne bissextile se dit de lanne de 366 jours sui revient gnralement tous les 4 ans.
17
UVT
2004
Chapitre 2
Algorithme Jours
DefVar
jj, mm, aa, jtot, jreste (Entier)
Dbut
Ecrire ("Donnez la date sous la forme JJ MM AA : ")
Lire (jj, mm, aa) -- On suppose que la date saisie par l'utilisateur est valide
Selon mm Faire
1, 3, 5, 7, 8, 10, 12 : jtot 31 -- Janvier, Mars, Mai, Juillet, Aot, Oct., Dc.
4, 6, 9, 11 : jtot 30 -- Avril, Juin, Sept. et Nov.
Sinon : -- mois de Fvrier
Si (aa Mod 4 = 0) -- Anne bissextile (fvrier a 29 jours)
Alors jtot 29
Sinon jtot 28
FinSi
FinSelon
jreste jtot - jj
Ecrire ("Le mois ", mm, " a ", jtot, " jours et il reste encore ", jreste, " jours pour sa fin")
Fin
Exemple 2 : criture d'un type scalaire (Sport).

Sachant que le type scalaire ne se lit pas et ne saffiche pas directement, on va crire un
algorithme qui permet de manipuler ce type de donnes.
Analyse :
Dfinir le type Sport.
Dclarer une variable entire S qui contient lordre du sport choisir.
Dclarer une variable Sp de type Sport.
Selon la valeur de la variable S, on va dterminer le sport choisi.
On affichera ensuite le nom du sport choisi.
Algorithme Ecriture_Scalaire
DefType
Sport = {Foot, Hand, Volley, Basket, Rugby} -- dfinition d'un type scalaire (Sport)
DefVar
sp (Sport) -- dclaration d'une variable de type Sport
s (Entier)
Dbut
Ecrire ("Donner un entier entre 1 et 5 :")
Lire (s)
Ecrire ("Le sport pratiqu est :")
Selon S Faire
1 : Sp Foot -- ou bien Sp Min(Sport)
Ecrire ("Foot ball") -- Dans certains langages, Ecrire(Sp) est autorise
2 : Sp Hand -- ou bien Sp Succ(Min(Sport))
Ecrire ("Hand ball")
3 : Sp Volley
Ecrire ("Volley ball")
4 : Sp Basket -- ou bien Sp Pred(Max(Sport))
Ecrire ("Basket ball")
5 : Sp Rugby -- ou bien Sp Max(Sport)
Ecrire ("Rugby")
Sinon :Ecrire ("Erreur de choix ! La plage autorise est 1..5)"
FinSelon

Fin
18
UVT
2004
LES STRUCTURESITERATIVES CHAPITRE
( LES BOUCLES ) 3
OBJECTIF
Construire des algorithmes en utilisant les structures de contrle itratives.
ELEMENTS DE CONTENU
1) INTRODUCTION ...........................................................................................................20
1.2. DEFINITION DU TRAITEMENT ITERATIF .......................................................................................... 20
2) LES STRUCTURES ITERATIVES ................................................................................20
2.1. LA STRUCTURE ITERATIVE : REPETER .. JUSQUA ......................................................................... 20
2.2. LA STRUCTURE ITERATIVE : TANTQUE .. FAIRE............................................................................. 22
2.3. LA STRUCTURE ITERATIVE : POUR .. FAIRE .................................................................................. 23
FIGURES
FIGURE 1 : SCHEMA REPETER .. JUSQU'A ................................................................................20

FIGURE 2 : SCHEMA TANTQUE .. FAIRE ...................................................................................22
FIGURE 3 : SCHEMA POUR .. FAIRE .........................................................................................23
19
UVT
2004
Chapitre 3
Structures itratives (Les boucles)
1) INTRODUCTION

En crivant des algorithmes, les structures de contrle, vues jusque l (instructions lmentaires ou
structures conditionnelles), ne sont pas suffisantes pour tout exprimer. En effet, lexemple suivant
confirme cette ide.
Exemple :
On se propose de calculer les moyennes du module Algorithmique et Structures de Donnes de tous
les tudiants inscrits en premire anne technologies de l'informatique dans une institution
universitaire. Supposons que pour ce module, chaque tudiant dispose de trois notes : une du devoir
surveill (NoteDS), une note dexamen (NoteEx) et une note d'orale (NoteOR). La moyenne se calcule
alors de la manire suivante :
Moyenne = ((NoteDS * 0.4 + NoteExam * 0.6) * 0.8) + (NoteOR * 0.2)
Pour chaque tudiant, on aura alors :
Saisir les trois notes NoteDS, NoteEx et NoteOR.
Calculer et Afficher la moyenne (Moyenne).
Si on a 200 tudiants par exemple, on aura rcrire ces trois instructions 200 fois !!! Absurde !...
Avec les instructions quon connat jusque l, on ne peut quadopter la solution quon vient de
proposer ! Cest pour cela quil faut disposer dautres instructions capables de mieux structurer un tel
traitement. Soient les structures itratives (les boucles).
1.2. DEFINITION DU TRAITEMENT ITERATIF

Les structures itratives sont utilises pour dcrire les rptitions d'une action ou d'un groupe
d'actions. Toute rptition d'actions doit tre finie. Ceci sera contrl l'aide d'une expression logique
ou condition dont le changement de valeur provoque l'arrt de la rptition. Cette condition est dite
condition de sortie ou darrt du traitement itratif. Dans ce qui suit, on va dvelopper trois schmas
itratifs :
La structure itrative : Rpter .. Jusqu
La structure itrative : TantQue .. Faire
La structure itrative : Pour .. Faire
2) LES STRUCTURES ITERATIVES
2.1. LA STRUCTURE ITERATIVE : REPETER .. JUSQUA

Le schma Rpter..Jusqu' exprime la rptition d'une squence d'instructions un certain nombre
de fois jusqu' ce qu'une expression logique soit remplie. Sa structure gnrale se prsente ainsi :
Figure 1 : Schma Rpter .. Jusqu
REPETER
Instruction 1
...
Instruction n
JUSQU'A (expression_logique)
20
UVT
2004
Chapitre 3
Remarques :
L'expression logique est teste aprs chaque excution du traitement, si elle n'est pas
vrifie la boucle s'arrte :
Si expression_logique = vrai Alors Arrt Sinon Excution
Si l'expression logique n'a pas t modifie, on aura dans ce cas une boucle infinie.
La squence d'instructions est excute au moins 1 fois.
Le nombre de rptitions dans la boucle n'est pas connu l'avance.
Exemple 1 : On veut lire une note comprise entre 0 et 20. On pose la question suivante
"Donnez une note dans l'intervalle 0..20" jusqu' ce que la rponse de l'utilisateur convienne.
Analyse - on a besoin de :
dclarer une variable nomme N de type Entier pour recevoir une note comprise entre 0 et 20
prciser l'utilisateur de saisir une note comprise entre 0 et 20. en cas de rponse incorrecte, on
lui donne la possibilit de rpter l'opration de saisie.
Algorithme Saisie_Note1
DefVar
N (Entier)
Dbut
Rpter
Ecrire ("Donnez une note dans l'intervalle 0..20") (1)
Lire(N) (2)
Jusqu' (N 0 et N 20)
Fin
Remarques :
Les mots Rpter et Jusqu' encadrent les deux instructions (1) et (2) : a signifie que
ces deux instructions doivent tre rptes autant de fois qu'il est ncessaire, et ceci
jusqu' ce que la variable N prenne une valeur comprise entre 0 et 20.
Notez bien que le nombre de rptition de ces deux instructions n'est pas indiqu
explicitement. Il dpendra ici de la valeur de N.
Exemple 2 : On veut adapter l'algorithme Saisie_Note1 pour que l'excution se prsente ainsi :
Donnez une note dans l'intervalle 0..20
25
Note invalide ! La plage autorise est 0..20
-1
...
Note invalide ! La plage autorise est 0..20
15
La note saisie est : 15
Analyse dans cet exemple on a besoin,

en cas de rponse incorrecte, d'avertir l'utilisateur en affichant le message suivant : "Note
invalide ! La plage autorise est 0..20" et de lui donner la possibilit de rpter l'opration
de saisie. Par contre la question initiale n'est pas repose.
d'afficher enfin la note saisie par l'utilisateur
21
UVT
2004
Chapitre 3
-- mme partie dclarative
Dbut
Ecrire ("Donnez une note dans l'intervalle 0..20")
Rpter
Lire(N)
Si (N 0 ou N 20) Alors
Ecrire ("Note invalide ! La plage autorise est 0..20")
FinSI
Jusqu' (N 0 et N 20)
Ecrire("La note saisie est : ", N)
Fin
2.2. LA STRUCTURE ITERATIVE : TANTQUE .. FAIRE
Le schma rptitif TantQue .. Faire est excut de manire rptitive aussi longtemps
que l'expression logique est vraie. Sa forme gnrale est la suivante :
Figure 2 : Schma TantQue .. Faire
TANTQUE (expression_logique) FAIRE

Instruction 1
Instruction 2
...
Instruction n
FINTANTQUE
Remarques :
L'expression logique est teste avant chaque excution du traitement itratif, si elle n'est
pas vrifie la boucle s'arrte :
Si expression_logique = vrai Alors Excution Sinon Arrt
Notez bien que si l'expression logique est fausse au dpart, alors la boucle n'est jamais
excute. Ce schma itratif pourra alors sexcuter 0 fois.
Le nombre de rptitions peut ne pas tre connu l'avance.
Exemple : On veut rcrire l'algorithme Saisie_Note2 en utilisant le schma TantQue..Faire :
DefVar
N (Entier)
Dbut
Ecrire ("Donnez une note dans l'intervalle 0..20")
Lire(N)
TantQue (N 0 ou N 20)
Ecrire ("Note invalide ! La plage autorise est 0..20")
Lire(N)
FinTantQue
Ecrire("La note saisie est : ", N)
Fin
22
UVT
2004
Chapitre 3
2.3. LA STRUCTURE ITERATIVE : POUR .. FAIRE
Le schma rptitif Pour..Faire permet simplement de rpter un ensemble d'instructions

un certain nombre de fois connu l'avance. Il s'utilise avec la syntaxe suivante :
Figure 3 : Schma Pour .. Faire
POURCompteur de Dbut Fin [PAS Incrment]FAIRE

Instruction 1
...
Instruction n
FINPOUR
Compteur : variable de contrle.

Dbut et Fin : respectivement les valeurs initiale et finale de la variable de contrle.
Incrment : Valeur d'incrmentation de Compteur aprs chaque excution de la boucle. Si aucune valeur
n'est indique, l'argument Pas prend par dfaut la valeur 1 comme valeur d'augmentation.
Remarques :
Dans cette structure rptitive Pour .. Faire on n'a pas besoin d'augmenter (ou diminuer) la valeur
du compteur chaque excution de la boucle puisque cette opration s'effectue
automatiquement.
Le nombre de rptitions dans la boucle Pour..Faire peut tre calcul en faisant la diffrence
entre la valeur initiale et la valeur finale laquelle on ajoute la valeur 1.
Exemple : Supposons que l'on souhaite rpter 10 fois les instructions permettant de lire un
nombre entier et d'en crire le carr.
-- Version 1 : -- Version 2 :
Algorithme Carre1 Algorithme Carr2
DefVar DefVar
Nombre, Carre, Compteur (Entier) Nombre, Carre, Compteur (Entier)
Dbut Dbut
Compteur 0 -Compteur initialis 0 Pour Compteur de 1 10 Faire
Rpter Lire(Nombre)
Compteur Compteur + 1 (1) Carre Nombre * Nombre
Lire(Nombre) (2) Ecrire("Carr = ", Carre)
Carre Nombre * Nombre (3) FinPour
Ecrire("Carr = ", Carre) (4) Ecrire("Fin du programme")
Jusqu' (Compteur = 10) Fin
Ecrire("Fin du programme")
Fin
Remarque : Les instructions (1)..(4) sont rptes Remarques : Dans cette version 2, on n'a pas
jusqu' ce que le compteur atteigne la valeur 10 ou bien besoin d'augmenter la valeur du compteur
Compteur 9 chaque excution de la boucle puisque cette
opration s'effectue automatiquement.
On a choisi 1 comme valeur initiale du compteur.
C'est effectivement la solution la plus simple mais
ce n'est pas la seule. Par exemple, de 100 109
23
UVT
2004
CHAPITRE
LES STRUCTURES
DE DONNEES COMPOSEES 4
OBJECTIF
Manipuler les types de donnes composs et leurs oprations.
ELEMENTS DE CONTENU
1. INTRODUCTION ..............................................................................................................25
1.2. CLASSIFICATION DES TYPES COMPOSES ...................................................................................... 25
2. LE TYPE TABLEAU ........................................................................................................25
2.1. TABLEAU UNIDIMENSIONNEL OU VECTEUR ................................................................................... 26
2.1. TABLEAU BIDIMENSIONNEL OU MATRICE ...................................................................................... 27
3. LE TYPE CHAINE DE CARACTERES ............................................................................28
3.1. DEFINITION ................................................................................................................................ 28
3.2. OPERATIONS DE MANIPULATION .................................................................................................. 29
4. LE TYPE ENREGISTREMENT ........................................................................................30
4.1. DEFINITION ................................................................................................................................ 30
4.2. EXEMPLE .................................................................................................................................. 30
FIGURES
FIGURE 1 : DEFINITION DUN TABLEAU UNIDIMENSIONNEL ........................................................................... 26

FIGURE 2 : DEFINITION DUN TABLEAU A DEUX DIMENSIONS ........................................................................ 27
FIGURE 3 : DEFINITION DUNE CHAINE DE CARACTERES.............................................................................. 28
FIGURE 4 : DEFINITION DUN ENREGISTREMENT ......................................................................................... 30
24
UVT
2004
Chapitre 4
Structures de donnes composes
1) INTRODUCTION
Jusque l, et avec les structures de donnes simples quon a dj dfinies (entier, rel,
caractre,), on nest capable de dfinir que des variables de types simples. En effet,
chaque variable ne peut contenir quune seule valeur la fois, toute valeur qui lui sera
affecte par la suite, dtruit lancienne.
On veut reprsenter lensemble des notes relatives a un ensemble dtudiants dune classe
donne dans un module. Soit la classe de premire anne informatique, le module tant
"Algorithmique et structures de donnes". Le nombre dtudiants est connu, soit 30. Il faudra
alors dclarer 30 variables relles indpendantes pour contenir chacune la note
correspondant un tudiant. Il serait alors plus commode te plus facile manipuler si on
avait une structure de donnes qui englobait toutes ses donnes. On parlera dune
Structure de donnes compose ou dun Type de donnes compos.
1.2. CLASSIFICATION DES TYPES COMPOSES

Un type compos contient une collection d'informations rparties en plusieurs champs, accessibles
individuellement ou collectivement.
Un type compos (structur) est homogne si toutes ses informations sont de mme type et
htrogne dans le cas contraire.
Type structur homogne : Un tableau d'entiers, une chane de caractres.
Type structur htrogne : Un enregistrement Etudiant contenant :
- Le numro de la carte d'tudiant de type entier.
- Le nom de type chane de caractres.
- Le prnom de type chane de caractres.
- L'ge de type entier.
- L'adresse de type chane de caractres.
2) LE TYPE TABLEAU
Le type tableau est une structure de donnes compose, constitue dlments qui ont le mme type,
quon appelle type de base. Le nom d'un composant de tableau utilise une ou plusieurs valeurs
d'indices appartenant des types discrets spcifis (Le type Entier et les types numratifs). La
valeur d'un objet tableau est une valeur compose constitue des valeurs de ses composants.
Un objet tableau est caractris par le nombre d'indices (la dimension du tableau), le type et la
position de chaque indice, les bornes infrieure et suprieure de chaque indice, et le type des
composants. L'ordre des indices est significatif.
Lorsque lindice est unique, le tableau est dit unidimensionnel (ou vecteur). Lorsque N indices sont
ncessaires pour reprer une valeur, le tableau est dit N dimensions (ou multidimensionnel). Les
valeurs possibles d'un indice donn sont toutes les valeurs comprises entre les bornes infrieure et
suprieure, bornes incluses ; cet intervalle de valeurs est appel l'intervalle d'indice.
25
UVT
2004
Chapitre 4
Les oprations applicables sur les lments de tableaux sont :

Lecture, pour assurer le remplissage.
Ecriture, pour la consultation ou laffichage
Affectation pour la modification
En plus, on retrouve toutes les oprations et les fonctions applicables sur le type de base du tableau.
2.1. TABLEAU UNIDIMENSIONNEL OU VECTEUR
La dfinition dun tableau unidimensionnel et dune variable de ce type se fait comme suit :
Figure 1 : Dfinition dun tableau unidimensionnel
DefConst
Binf (Entier) = -- Borne infrieure
Bsup (Entier) = -- Borne Suprieure
DefType
Dimension = -- Type scalaire (numr ou intervalle)
Nom_Type1 = Tableau [Binf..Bsup] de Type_Base
Nom_Type2 = Tableau [Dimension] de Type_Base
DefVar
T (Nom_Type1) -- Dclaration dune variable T de type

Type_Base : est le type des composants du vecteur (Numrique, Caractre,
Nom_Type1
Logique, Chane de caractres, Tableau, Enregistrement, Scalaire).
Accs un composant (une case) d'indice i : T [ i ] avec Binf i BSup
Exemple : On veut saisir 30 moyennes comprises entre 0 et 20 et les stocker dans un

vecteur de Rel nomm Moy, puis afficher son contenu l'cran, enfin calculer et afficher la
moyenne gnrale.
Algorithme Moy_Gnrale
DefConst
BSup (Entier) = 30
DefType
Moyennes = Tableau [1..BSup] de Rel
DefVar
Moy (Moyennes)
i (Entier)
Total, MoyG (Rel)
Dbut
Total 0
Pour i de 1 Bsup Faire
Ecrire("Saisir la moyenne N : ", i)
Rpter -- cette boucle permet de saisir au clavier une
Lire(Moy[i]) -- moyenne comprise entre 0 et 20 et la
Jusqu (Moy[i] 0 Et Moy[i] 20) -- conserver dans la case N i du vecteur Moy
Total Total + Moy[i]

FinPour
26
UVT
2004
Chapitre 4
Ecrire("Voici les moyennes saisies : ")

Pour i de 1 Bsup Faire -- cette boucle permet de parcourir toutes les
Ecrire(Moy[i]) -- cases du vecteur Moy afin d'afficher leur
-- contenu
FinPour
MoyG Total/BSup
Ecrire("La moyenne gnrale est : ", MoyG)
-- ou bien Ecrire("La moyenne gnrale est : ", Total/BSup)
Fin
2.1. TABLEAU BIDIMENSIONNEL OU MATRICE

La notation algorithmique d'un tableau bidimensionnel ( 2 dimensions) se prsente ainsi :
Figure 2 : Dfinition dun tableau deux dimensions
DefType
Dim1 = -- type intervalle ou type numr
Dim2 = -- type intervalle ou type numr
Nom_Type = Tableau [Dim1, Dim2] de Type_Base
DefVar
T (Nom_Type) -- Dclaration dune variable T de type Nom_Type
Exemple : un tableau 2 dimensions (bidimensionnel) correspond la notion mathmatique

de matrice. Comme le montre la figure suivante, la 1re dimension, horizontale, reprsente
les lignes du tableau, et la seconde dimension, verticale, reprsente les colonnes.
1re dimension Tableau deux dimensions (30,5) nomm Notes 2me dimension
1 2 3 4 5
1 10 12 11 15 9
2 8 13 12,5 12 10
3 15 12 13 10 17

30 10,5 8,5 9 10 11,5
Le tableau Notes schmatis ci-dessus reprsente le cas des notes de 30 tudiants dans 5
matires. Il est donc constitu de 30 lignes et 5 colonnes et comporte 150 lments de type Rel.
On accde l'tudiant numro 3 dans la matire 5 par la notation Notes[3,5], et plus
gnralement la valeur de la ligne ldans la colonne c par la notation Notes[l,c].
Exemple : Remplissage du tableau bidimensionnel Notes
Algorithme Matrice
DefConst
Etudiants (Entier) = 30
Matieres (Entier) = 5
DefType
Tab_Notes = Tableau [1..Etudiants, 1..Matieres] de Rel
27
UVT
2004
Chapitre 4
DefVar
Notes (Tab_Notes)
NumEtud, NumMat (Entier)
Dbut
Pour NumEtud de 1 Etudiants Faire
Ecrire("Pour l'tudiant : ", NumEtud)
Pour NumMat de 1 Matires Faire
Ecrire("Saisir la note : ", NumMat)
Rpter
Lire(Notes[NumEtud,NumMat])
Jusqu (Notes[NumEtud,NumMat] 0 Et Notes[NumEtud,NumMat] 20)
Fin pour
Fin pour
Fin
3) LE TYPE CHAINE DE CARACTERES
3.1. DEFINITION
Une chane de caractres est une structure de donnes permettant de reprsenter toute
squence de caractres :
La longueur maximale que la chane est susceptible d'atteindre est de 255 caractres.
Une chane est toujours entoure de guillemets ("chane") ou apostrophes ('chane').
On peut avoir une chane de caractres vide ("") ayant une longueur gale 0.
Une variable de type Chane de caractres est dclare comme suit :
Figure 3 : Dfinition dune chane de caractres
DefVar
Nom (Chane) -- Nom est une variable de type chane de taille indfinie
Adresse (Chane[50]) -- Adresse est une variable de type chane de taille 50
Remarques :
La lecture, l'criture et l'affectation sont des oprations applicables sur les variables de
type Chane
Les oprateurs relationnels (=, , , , , ) s'appliquent aux chanes de caractres. On
peut, par exemple, tester l'galit ou l'ingalit de 2 chanes de mme longueur.
ch[i] permet d'accder au ime caractre de la chane ch (avec i [1, Long(ch)])
Exemples :
"A" < "a" : vrai car ASC("A") est infrieur ASC("a")
"ISET Rads" > "ISET Sousse" : faux car ASC("R") est infrieur ASC("S")
"iset" "ISET" : vrai car ASC("i") est diffrent de ASC("I")
28
UVT
2004
Chapitre 4
3.2. OPERATIONS DE MANIPULATION
On dfinit un certain nombre de fonctions sur les chanes qui sont les suivantes :
Long (ch) : rend la longueur de la chane ch (en nombre de caractres).

Long("TUNISIE") renvoie 7
Majus (ch) : convertit la chaine ch en majuscule.

Majus("#Tunisie 2030#") renvoie "#TUNISIE 2030#"
Concat (ch1, ch2) : donne la chane obtenue par concatnation des ch1 et ch2
Concat("Tunisie", " 2030") renvoie "Tunisie 2030"
Copier (ch, pos, n) : copie n caractres de la chane ch partir de la position pos.

Copier ("Tunisie 2030", 4, 4) renvoie "isie"
Copier ("Tunisie 2030", 9, 10) renvoie "2030"
Position (ch1, ch2) : retourne la position de la premire occurrence de la chane ch1

dans la chane ch2 si ch1 est dans ch2, sinon 0.
Position ("2030", "Tunisie 2030") renvoie 9
Position ("tun", "Tunisie 2030") renvoie 0
Position ("i", "Tunisie 2030") renvoie 4
Valeur(ch, n, err) : convertit la chane ch en une valeur numrique. Elle renvoie Zro dans
le paramtre entier err si la conversion est possible.
Valeur("2030", n, err) renvoie 2030 dans n et 0 dans err
Valeur("Tunisie 2030", n, err) renvoie 1 dans err.
Valeur("2030 Tunisie", n, err) renvoie 5 dans err.
Chaine(nb) : convertit le nombre nb en chane de caractres.

Valeur(2030) renvoie "2030".
Exemple:Dfinir une variable, de type chane de 20 caractres, puis lire et crire cette variable.
Algorithme LectureChane
DefVar
NomEtudiant (Chane[20])
Dbut
Ecrire ("Saisir le nom de l'tudiant ( 20 caractres) : ")
Lire (NomEtudiant) -- exp : Ben Abdallah Mohamed Ali
Ecrire ("Le nom saisi : ", NomEtudiant) -- Le nom saisi est : Ben Abdallah Mohamed
Fin
Remarque : pour afficher tous les caractres saisis (c..d. Ben Abdallah Mohamed Ali), il faut
augmenter la taille de la variable NomEtudiant 24 caractres au minimum.
29
UVT
2004
Chapitre 4
4) LE TYPE ENREGISTREMENT
4.1. DEFINITION
Le type enregistrement ou article est une structure de donnes constitue dun nombre fixe de
composants nomms Champs qui peuvent tre de types diffrents. La valeur d'un objet article est
une valeur compose, constitue des valeurs de ses composants. Chaque champ a un nom.
La dclaration d'un article se fait da la manire suivante :
Figure 4 : Dfinition dun enregistrement
Def Type
Structure Type_Article
Champ1 : Type_Champ1
Champ2 : Type_Champ2

ChampN : Type_ChampN
Fin Structure
Def Var
Art (Type_Article) -- Dclaration dune variable Art de type Type_Article
Type_Article : est lidentificateur de type article (enregistrement).

Type_Champ : est le type des composants de l'article (Numrique, Caractre, Boolen, Chane
de caractres, Tableau, Article).
Remarque : Laccs un champ se fait par l'identificateur de la variable article suivi d'un point (.) puis
l'identificateur du champ. Dans cet exemple, on fait : Art.Champ2 pour accder au champ2.
4.2. EXEMPLE
On se propose de dclarer un type article reprsentant un tudiant, les diffrents champs

relatifs sont les suivants :
Nce : Numro de la carte dtudiant de type Entier (ou Chane[8]).
NP : Nom et Prnom de ltudiant de type Chane[25].
DatNais : Date de naissance de ltudiant de type Date qui est compose de :
Jour : De type intervalle dentier compris entre 1 et 31.
Mois : De type intervalle dentier compris entre 1 et 12.
An : de type Entier.
LieuNais : Lieu de naissance de ltudiant de type Chane[15].
Adr : Adresse de ltudiant de type Chane[50].
Exemple :On veut maintenant saisir toutes les informations relatives un ensemble de 30 tudiants
(une classe). Soit lalgorithme suivant :
Algorithme Info_Etudiant
DefConst
Taille (Entier) = 30
DefType
Structure Date
Jour : 1..31
Mois : 1..12
An : Entier
Fin Structure
30
UVT
2004
Chapitre 4
Structure Etudiant
Nce : Chane[8]
NP : Chane[25]
DatNais : Date
LieuNais : Chane[15]
Adr : Chane[30]
Fin Structure
Tab_Etudiant = Tableau[1..Taille] de Etudiant
DefVar
T (Tab_Etudiant) -- T est un tableau d'tudiants
i (Entier) -- Compteur pour le nombre dtudiants
Dbut
Ecrire("Saisie des informations relatives aux tudiants : "
Pour i de 1 Taille Faire
Ecrire("Etudiuant :", i)
Ecrire("Nce : ")
Lire(T[i].Nce) -- T[i].Nce permet d'accder au
Ecrire("Nom et Prnom: ") -- champ Nce de l'tudiant Ni
Lire(T[i].NP)
Ecrire("Date de Naissance : ")
Lire(T[i].DatNais.jour) -- T[i].DatNais.jour permet d'accder
Lire(T[i].DatNais.mois) -- au champ jour de la date naissance
Lire(T[i].DatNais.an) -- DatNais de l'tudiant Ni
Ecrire("Lieu de Naissance : ")
Lire(T[i].LieuNais)
Ecrire("Adresse : ")
Lire(T[i].Adr)
FinPour
Fin
Remarque :
Il faut ajouter cet algorithme tous les contrles de saisie. Par exemple, le jour de naissance
doit tre compris entre 1 et 31 en utilisant la structure itrative Rpter..Jusqu'.
31
UVT
2004
CHAPITRE
LES SOUS-PROGRAMMES
PROCEDURES & FONCTIONS 5
OBJECTIF
Appliquer les constructions modulaires dans lcriture des algorithmes.
ELEMENTS DE CONTENU
1. ANALYSE DESCENDANTE ............................................................................................33

1.1. PRINCIPE .................................................................................................................................. 33
1.2. NOTION DE MODULE .................................................................................................................. 34
1.3. NOTIONS COMPLEMENTAIRES..................................................................................................... 34
2. LES PROCEDURES ........................................................................................................35
2.1. DEFINITION ET DECLARATION ..................................................................................................... 35
2.2. PROCEDURE SANS PARAMETRE .................................................................................................. 36
2.3. PROCEDURE AVEC PARAMETRES ................................................................................................ 38
2.4. PASSAGE DE PARAMETRES ........................................................................................................ 39
3. LES FONCTIONS ............................................................................................................40
3.1. PASSAGE DE PARAMETRES ........................................................................................................ 40
3.2. EXEMPLES ................................................................................................................................ 41
FIGURES
FIGURE 1 : ANALYSE DESCENDANTE ....................................................................................... 33

FIGURE 2 : EXEMPLE DAPPEL DACTIONS ................................................................................ 33
FIGURE 3 : STRUCTURE GENERALE D'UN PROGRAMME ............................................................. 35
FIGURE 4 : DEFINITION DUNE PROCEDURE .............................................................................. 35
FIGURE 5 : DEFINITION DUNE FONCTION ................................................................................. 40
32
UVT
2004
Chapitre 5
Les Sous-Programmes (Procdures & Fonctions)
1) ANALYSE DESCENDANTE
Diviser les difficults en autant de parcelles qu'il se peut afin de les mieux rsoudre
DESCARTES
1.1. PRINCIPE
L'analyse descendante permet de traduire une action complexe par dcompositions successives en
actions de plus en plus simples, ne contenant finalement que des actions primitives.
Une action primitive pour un processeur donn est une action dont l'nonc est suffisant en lui-mme
pour que le processeur puisse excuter l'action sans autre information.
La figure suivante fait apparatre les niveaux hirarchiques de dcomposition d'une action A, dcrite
par un nonc non primitif. Les actions dcomposer sont inscrites dans des cercles, tandis que les
actions primitives sont inscrites dans des rectangles.
Figure 1 : Analyse descendante
Dbut Action A
A Action A1
Niveau Action A2
A1 A2 0 Fin Action A
Dbut Action A2
Niveau Action A21
1 Action A22
A21 A22 Fin Action A2
Niveau
2
Analyse descendante de l'action complexe A sur 2 niveaux Structure algorithmique de l'action A
L'algorithmique utilise l'analyse descendante dans l'criture des actions complexes, dcrites dans des
sous-programmes (modules), appels actions nommes. L'intrt de cette mthode est de permettre
l'analyste du problme de structurer la solution, en partant des lments les plus gnraux pour aller
vers les lments de dtails particuliers.
Comme le montre la structure algorithmique de l'action A, le bloc A contient les blocs A1 et A2 qui
sont, dans l'ordre, les actions excuter pour raliser l'action A. De mme, les blocs A21 et A22,
imbriqus dans le bloc A2, ralisent le bloc A2.
L'criture d'un algorithme fait apparatre des actions nommes qui peuvent tre appeles une ou
plusieurs fois. Dans l'algorithme suivant l'Action 1, dont le contenu ne sera dtaill qu'une seule fois
dans l'action nomme, est appele deux fois par le corps de l'algorithme.
Figure 2 : Exemple dappel dactions
Dbu
Dbut algorithme
Action 1 t Action 1

Action 2
Action 2
Action 1
Action 3
Action 3

Algorithme Organigramme
33
UVT
2004
Chapitre 5
Ceci peut se rsumer par le schma suivant :

Dbut
Analyser un problme, cest :
Dfinir le problme
Le dcomposer en sous-problmes
Pour chaque sous-problme Faire
Si la solution est vidente
Alors Ecrire le morceau de lalgorithme
Sinon Analyser le sous-problme
Fin Si
Fin Pour
Fin
Cette analyse descendante a pour but de :

Rpartir les difficults.
Faciliter la rsolution d'un problme complexe.
Pouvoir poursuivre l'analyse comme si les sous-problmes taient rsolus.
Faciliter l'criture de l'algorithme en vitant les duplications.
Les langages de programmation reprennent ces structures d'actions nommes et les enrichissent au
travers des procdures et des fonctions. Leur utilisation permet au programmeur d'amliorer la
lisibilit du programme, d'en faciliter la maintenance et de n'avoir crire qu'une seule fois dans une
procdure ou une fonction, une action appele plusieurs fois par le programme.
1.2. NOTION DE MODULE
La conception d'un algorithme procde en gnral par des affinements successifs : On dcompose le
problme rsoudre en sous-problmes, puis ces derniers leur tour, jusqu' obtenir des problmes
"faciles rsoudre". Pour chaque sous-problme, on crira un module.
Ainsi, la rsolution du problme sera compose d'un algorithme principal et d'un certain nombre de
modules. L'algorithme principal a pour but d'organiser l'enchanement des modules.
Un module est une unit fonctionnelle forme d'un bloc d'instructions, nomme et ventuellement
paramtre, que l'on dclare afin de pouvoir l'appeler par son nom en affectant s'il y a lieu des
valeurs ses paramtres. Les donnes fournies au module et les rsultats produits par ce dernier
sont appels des arguments ou des paramtres. Un module peut tre une procdure ou une
fonction.
1.3. NOTIONS COMPLEMENTAIRES
Dautres notions savrent importantes pour expliquer le mode de fonctionnement des modules et leur
interaction, en voici dans ce qui suit quelques dfinitions :
Appel ou invocation : Il s'opre lorsqu'un module a besoin des services d'un autre. Il faut
distinguer alors entre le module appelant ou englobant (celui qui fait l'appel) et le module appel
ou englob (celui qui subit l'appel).
Retour : Lorsque l'excution du module appel s'achve, on revient au module appelant qui
poursuivra son excution l'action qui se trouve juste aprs l'action d'appel : On dit que le module
appel effectue un retour.
Communication de donnes : l'appel, des donnes sont communiques de l'appelant
l'appel. Au retour, c'est l'inverse qui se produit : Les rsultats passent de l'appel l'appelant.
34
UVT
2004
Chapitre 5
Variables locales et variables globales : Tout module peut manipuler outre ses paramtres, des
variables intermdiaires ncessaires aux traitements : Ce sont les variables locales qui ne seront
pas accessibles en dehors du module o elles sont dclares, contrairement aux
variablesglobales qui sont dclares au niveau gnral et qui sont accessibles tous les
modules appels.
Figure 3 : Structure gnrale d'un programme
-- partie dclarative gnrale (globale)

Algorithme nom_algorithme
-- partie dclarative locale
Dbut
-- corps de l'algorithme
Fin
Procdurenom_procdure1[(paramtres)]
Dbut
-- corps de la procdure
Fin

Fonction nom_fonction1[(arguments)] : type_rsultat
Dbut
-- corps de la fonction
Fin

2) LES PROCEDURES
2.1. DEFINITION ET DECLARATION

Une procdure est un module ralisant une action sur une partie des donnes de l'algorithme. La
structure d'une procdure est identique celle d'un algorithme. Elle est constitue d'un en-tte, d'une
partie dclarative et d'un corps.
Dans l'algorithme, la procdure se prsente sous la forme :

Figure 4 : Dfinition dune procdure
Procdure Nom_Procdure [(paramtres)]

-- Partie des dclarations
Dbut
-- Corps de la procdure
Fin
(identificateur[, identificateur] : type [; identificateur[, identificateur] : type])
L'identificateur Nom_Procdure est utilis, dans l'algorithme appelant la procdure, comme

instruction d'appel ou d'activation de la procdure.
Les paramtres sont utiliss dans le cas o la communication des informations entre l'algorithme
appelant et la procdure devrait se raliser sous une forme spcifique. Nous reviendrons plus tard
sur les modes de passage des paramtres. La liste de paramtres peut tre vide.
La partie des dclarations et le corps de la procdure sont structurs respectivement comme la
partie dclarative et le corps d'un algorithme.
35
UVT
2004
Chapitre 5
2.2. PROCEDURE SANS PARAMETRE

Dans l'algorithme, l'analyste du problme crit d'abord les actions principales qui sont souvent des
actions complexes, puis va crire le dtail de ces actions dans les actions nommes (procdures).
Cette faon de procder respecte parfaitement le principe de l'analyse descendante selon lequel la
traduction d'une action complexe se fait par dcompositions successives. La dclaration et l'criture
d'une action nomme figure donc aprs son appel. En algorithmique, on tolre lcriture dune action
nomme avant son appel.
Remarque : une rgle de certains langages de programmation (par exemple, Pascal) prvoit qu'un
module ne peut tre appel que sil a t dclar, c'est dire connu, avant l'instruction d'appel. Par
contre, en langage C ou en VB, les modules peuvent tre mis dans nimporte quel ordre.
Exemple 1 : Calculer l'expression A+B-C, par une procdure CalculABC , pour deux valeurs
diffrentes de A, B et C (par exemple : 21, 9 et 5 & 6,14 et 8).
DefVar Procdure CalculABC

A, B, C, Rsultat (Entier) Dbut
Algorithme Calcul1 Rsultat A +B -C
Dbut Ecrire ("Rsultat = ", Rsultat)
A 21 Fin
B 9
C 5
Ecrire ("Premier appel :") Affichage cran :
CalculABC Premier appel : Rsultat = 25
Second appel : Rsultat = 12
A 6
B 14
Remarque :
C 8
La procdure CalculABC est appele deux fois avec
Ecrire ("Second appel :")
des valeurs diffrentes, pour effectuer le mme calcul.
CalculABC
Cette procdure agit sur des variables globales
Fin
dfinies au niveau de lalgorithme qui lappelle.
Exemple 2 : Un algorithme qui ordonne dans le sens croissant 2 variables en changeant leurs
valeurs si ncessaire. Mettre en uvre une procdure de saisie Saisie des donnes et une procdure
dchange Echange.
DefVar Procdure Saisie

Petit, Grand, Aux (Rel) Dbut
OK (Boolen) Ecrire ("Saisir la 1re valeur :")
AlgorithmeCalcul2 Lire (Petit)
Dbut Ecrire ("Saisir la 2me valeur :")
Saisie Lire (Grand)
Si (Ok = Faux) Alors--ou (Non OK) OK (Petit Grand)
Echange Fin
FinSi Procdure Echange
Ecrire ("Valeurs ordonnes :") Dbut
Ecrire (Petit, Grand) Aux Petit
Fin
Petit Grand
Grand Aux
Fin
36
UVT
2004
Chapitre 5
Remarque : lalgorithme Calcul2 contient trois actions : laction principale et les deux actions
nommes (procdures) Saisie et Echange.
Porte des variables :

Dans les deux exemples prcdents, toutes les variables sont dclares dans la partie dclarative
gnrale. Ces donnes sont reconnues et manipules aussi bien par laction principale que par les
actions nommes (ou procdures). Elles ont une porte globale sur lalgorithme. On parle dans ce cas
de Variables Globales.
Lexemple 3 suivant va faire apparatre des variables dclares dans la partie dclarative, au sein des
procdures. Ces variables ne seront reconnues et manipules que par la procdure qui les met en
jeu. On parle dans ce cas de Variables Locales.
Exemple 3 :
Reprendre lexemple 2 en appelant laction Echange partir de laction Saisie. Etude de la porte
des variables et mise en uvre de variables locales ncessaires aux actions nommes de
lalgorithme.
Analyse de la porte des variables :

Les variables Petit et Grand, utilises par toutes les actions, doivent tre dclares comme variables globales.
La variable OK nest manipule que dans laction Saisie. Elle est sera donc dclare localement dans Saisie.
La variable supplmentaire Aux nintervient que dans laction Echange, il est donc inutile de la dclarer en
dehors de laction Echange.
DefVar Procdure Saisie

Petit, Grand (Rel) DefVar
AlgorithmeCalcul3 OK (Boolen)
Dbut Dbut
Saisie Ecrire ("Saisir la 1re valeur :")
Ecrire ("Valeurs ordonnes :") Lire (Petit)
Ecrire (Petit, Grand) Ecrire ("Saisir la 2me valeur :")
Fin Lire (Grand)
OK (Petit Grand)
Procdure Echange Si (Ok = Faux) Alors
DefVar Echange
Aux (Rel) FinSi
Dbut Fin
Aux Petit
Petit Grand
Grand Aux
Fin
Remarques:
Lanalyste du problme aura toujours intrt dclarer localement un module, tous les types, les
constantes, les variables et mme les modules, quil naura pas utiliser en dehors de ce module.
Ce que nous venons de dire propos de la porte de variables est vrai pour tout identificateur, quil
soit de variable, de constante, de type ou mme pour les identificateurs de modules. Un module
peut tre visible ou invisible par rapport un autre module. Il ne peut tre appel que sil est visible
(exemple, le langage Pascal).
37
UVT
2004
Chapitre 5
2.3. PROCEDURE AVEC PARAMETRES

Les procdures appelante et appele peuvent avoir besoin de se communiquer des informations.
Cette communication est tablie laide de paramtres qui vont apparatre la fois dans
linstruction dappel et dans len-tte de la procdure appele.
Lorsque len-tte de la procdure contient des paramtres, ceux-ci portent le nom de paramtres
formels (ou paramtres fictifs). Ils sont reprsents par des identificateurs sur lesquels la
procdure va travailler et qui sont locaux la procdure.
Lorsque linstruction dappel contient des paramtres, ceux-ci portent le nom de paramtres
rels (ou paramtres effectifs). Ils communiquent des informations la procdure appele, dans
laquelle ils viennent se substituer aux paramtres formels.
Dans un algorithme, les procdures paramtres peuvent mettre en uvre deux modes de
paramtres formels :
1. Le paramtre Donne , dont la valeur reste inchange dans la procdure appelante aprs
excution de la procdure appele. Dans la structure de len-tte de la procdure appele, le mot
rserv Don prcde le paramtre Donne (Don est le mode de passage par dfaut).
Module Appelant Don (IN)

Module Appel
Exemple
Algorithme Donne Procdure Proc (Don B : Entier) // (B: Entier)
DefVar Prcond : B 0
A (Entier) Dbut
--A est locale Donne Ecrire ("B = ", 2/B)
Dbut Fin
Lire (A)
Ecrire ("A = ", A) Affichage cran :
-- A est dj dfinie A = 4 -- Valeur saisie au clavier
Proc (A) B = 0,5 -- Premier appel (dans Proc)
-- A garde sa valeur initiale A = 4 -- aprs le premier appel
Ecrire ("A = ", A) -- Second appel : Erreur dexcution,
Proc (A-4) -- car la Prcond nest pas respecte
Ecrire ("A = ", A) -- Donc, laction : Ecrire ("A = ", A)
Fin -- ne sera pas excute.
2. Le paramtre Donne/Rsultat, dont la valeur est modifie dans la procdure appelante au

moment mme o elle est modifie dans la procdure appele. Dans la structure de len-tte de la
procdure appele, le mot rserv VAR (ou DonRes) prcde le paramtre Donne/Rsultat.
VAR (DONRES ou INOUT)

Module Appelant Module Appel

Exemple
Algorithme Donne_Rs Procdure Proc (Don C : Entier, VAR D : Entier)
DefVar Dbut
A, B (Entier) D -D - C
Dbut Si (D 0) Alors
A 3 D -D
B 4 Fin Si
Proc (A, B) Fin
Ecrire ("B = ", B)
Proc (A*B, B) Affichage cran :
Ecrire ("B = ", B) B = 7 -- Aprs premier appel
Ecrire ("A = ", A) B = 28 -- Aprs second appel
Fin A = 3
38
UVT
2004
Chapitre 5
Les sous-programmes (Procdures et Fonctions)
Remarques : Les paramtres rels (d'appel) doivent correspondre en nombre, en type et

en position aux paramtres formels de la procdure (module).
2.4. PASSAGE DE PARAMETRES
Paramtres par valeur (Call by Value) : Le paramtre effectif est une expression qui est
value dans la procdure appelante. Linstruction dappel donne au paramtre effectif la
valeur rsultant de cette valuation ; cette valeur est transmise la procdure appele
dans laquelle elle prend la place du paramtre formel. Le paramtre formel est toujours
une variable locale la procdure appele. Dans la structure de len-tte de la procdure
appele, le mot rserv Don prcde les paramtres formels.
Paramtres par variable ou par rfrence (Call by Reference) : Le paramtre effectif
est ici une variable et non plus une expression. Linstruction dappel mentionne les
variables transmises la procdure appele, dans laquelle elles sont repres par les
paramtres formels. La procdure appele travaille sur des variables formelles ayant les
mmes adresses que les variables effectives. Dans la structure de len-tte de la
procdure appele, le mot rserv Var (DonRes) prcdent les paramtres formels.
Remarques :
Au dbut de chaque appel, si le mode est Don, la valeur du paramtre rel est copie dans le
paramtre formel associ ; puis aprs achvement normal du corps de la procdure, la valeur du
paramtre formel nest pas copie au retour dans le paramtre rel associ.
Pour le mode DonRes (VAR), le passage ou bien la substitution des paramtres rels aux
paramtres formels est ralis par variable (ou par rfrence). Aprs achvement normal du corps
de la procdure, la valeur du paramtre formel est copie au retour dans le paramtre rel
associ.
Exemple 1 :Lobjectif de lalgorithme suivant est dutiliser un paramtre par valeur, pour doubler une
valeur, puis dutiliser un paramtre par variable pour tripler une variable, et enfin dobserver les
rsultats.
Algorithme DoubleTriple Procdure Triple (VAR C : Entier)

DefVar Dbut
A (Entier) C 3 * C
Dbut Ecrire ("Variable triple = ", C)
Ecrire ("Saisir un nombre entier") Fin
Lire (A)
Ecrire ("Nombre = ", A)
Double (A) Excution :
Ecrire ("Nombre = ", A) Saisir un nombre entier
Triple (A) 10
Ecrire ("Nombre = ", A) Nombre = 10
Fin Valeur double = 20
Nombre = 10
Procdure Double (Don B : Entier) Valeur triple = 30
Dbut Nombre = 30
B 2 * B
Ecrire ("Valeur double = ", B)
Fin
39
UVT
2004
Chapitre 5
Exemple 2 : La procdure Echange utilise dans les algorithmes Calcul2 etCalcul3 peut
tre redfinie avec des paramtres par variable :
Procdure Echange (VAR V1, V2 : Rel)

DefVar
X (Rel)
Dbut
X V1
V1 V2
V2 X
Fin
Rsum : les diffrents modes de passage sont rsums dans le tableau suivant :
Don DonRes (VAR)
Contrainte ne doit jamais tre modifi Aucune
Valeur initiale doit tre dfinie dans le module appelant doit tre dfinie dans le module appelant
Valeur finale identique la valeur initiale doit tre dfinie dans le module appel
3) LES FONCTIONS
3.1. PASSAGE DE PARAMETRES

Une fonction est un module charg de calculer une valeur partir d'une partie des donnes de
l'algorithme. Contrairement la procdure qui est appele de l'algorithme principal travers une
instruction, la fonction est appele partir d'une expression de l'algorithme principal, dans laquelle
elle retourne une valeur d'un type prcis dans l'en-tte du module appel.
Les fonctions cres par l'analyste du problme feront intervenir un ou plusieurs paramtres. On
utilise souvent le terme Argument pour dsigner un paramtre de fonction.
Dans l'algorithme, la fonction se prsente sous la forme :
Figure 5 : Dfinition dune fonction
Fonction Nom_Fonction (Arguments) : Type_Rsultat

-- Partie des dclarations
Dbut

Nom_Fonction -- (a)

Fin
(identificateur[, identificateur] : type [; identificateur[, identificateur] :

type])
Type_Rsultat : c'est le type de la valeur retourne par la fonction.
(a) : c'est une instruction d'affectation de l'identificateur de la fonction. Cet identificateur
(Nom_Fonction) doit imprativement prendre une valeur pour que la fonction puisse la retourner
dans l'expression du module appelant.
Arguments : ils doivent avoir le mode de passage par valeur Don.
40
UVT
2004
Chapitre 5
3.2. EXEMPLES
Exemple 1 : Fonction de calcul de la surface d'un disque.
Algorithme Calcul_Surface
DefVar
Rayon, S (Rel)
Dbut
Ecrire ("Saisir le rayon du disque : ")
Lire (Rayon)
S Surface(Rayon)
Ecrire ("Surface = ",)
-- Ou bien, on peut directement appeler la fonction Surface dans Ecrire
Ecrire ("Surface = ", Surface(Rayon))
Fin
Fonction Surface (R : Rel) : Rel

DefConst
Pi (Rel) = 3.14159
Dbut
Surface Pi * R* R
Fin
Exemple 2 :Recherche de maximum dans une srie de n nombres positifs, saisis par l'utilisateur, en
mettant en uvre une fonction de calcul du maximum de 2 nombres rels.
Algorithme Recherche_Max
DefVar
i, n (Entier)
Max, Elment (Rel)
Dbut
Max 0
Ecrire ("Saisir le nombre d'lments : ")
Lire (n)
Pour i de 1 n Faire
Ecrire ("Saisir l'lment numro ", i)
Lire (Elment)
Max PlusGrand (Max, Elment)
Fin Pour
Ecrire ("Maximum : ", Max)
Fin
Fonction PlusGrand (Don X, Y : Rel) : Rel

Dbut
Si (X Y)
Alors
PlusGrand X
Sinon
PlusGrand Y
FinSi
Fin
Remarques :
Les paramtres d'appel doivent correspondre en nombre, en type et en position aux paramtres
formels de la fonction.
La liste des paramtres peut tre vide mais elle comporte gnralement au moins un paramtre.
Toute procdure, qui retourne un seul rsultat, peut tre remplace par une fonction. Le rsultat
sera rcupr dans l'identificateur de la fonction.
41
UVT
2004
CHAPITRE
LA RECURSIVITE
6
OBJECTIF
Rsoudre des problmes dfinis rcursivement.
ELEMENTS DE CONTENU
1. NOTION DE RECURSIVITE............................................................................................. 43
1.1. DEFINITION ................................................................................................................................43
1.2. TYPES DE RECURSIVITE ..............................................................................................................44
1.3. NOTIONS DE BASE ......................................................................................................................44
2. ITERATION OU RECURSIVITE ....................................................................................... 46

2.1. REDONDANCE DES TRAITEMENTS ................................................................................................46
2.2. SOLUTION ITERATIVE NON EVIDENTE............................................................................................47
2.3. DEFINITION DALGORITHMES RECURSIFS ......................................................................................48
3. LE JEU DES TOURS DE HANOI ..................................................................................... 48

3.1. DEFINITION DU PROBLEME ..........................................................................................................48
3.2. ALGORITHME..............................................................................................................................49
FIGURES
FIGURE 6.1 : RECURSIVITE DIRECTE ........................................................................................................ 44

FIGURE 6.2 : RECURSIVITE INDIRECTE ..................................................................................................... 44
FIGURE 6.3 : ARBRE DEXECUTION (TRACE) DE LA FONCTION FIBO (4)....................................................... 46
FIGURE 6.4 : TOURS DE HANOI : HANOI(3,A,B,C) .................................................................................... 49
42
UVT
2004
Chapitre 6
La rcursivit
1) NOTION DE RECURSIVITE
1.1 DEFINITION
La rcursivit est un concept trs puissant si on arrive dcomposer un problme en un ou

plusieurs sous-problmes qui sont de mme nature. Il est de mme quand on dcompose un
objet en groupes de composants qui prsentent les mmes proprits et qui ne contiennent
qu'un sous-ensemble de l'objet. Une notion est dite rcursive si elle, entre, elle mme dans
sa composition ou dans sa dfinition.
Exemples :
Mon ascendant est mon pre, ma mre ou un de leurs ascendants
De mme, un algorithme est dit rcursif sil fait appel lui-mme. Ainsi, la fonction factorielle :
n! = (n-1)! * n
Cette expression ne fait que dplacer le problme de lordre n lordre n-1, sans le rsoudre. Par
bonheur, en faisant ainsi dcrotre lordre, on parvient une relation sans indtermination : 1! = 1 (ou
ventuellement (0 ! = 1). Grce cette proprit, le traitement rcursif de la factorielle nest pas un
cercle vicieux. Son algorithme scrit :
Algorithme Rcursif Algorithme Itratif
Fonction Factorielle (Don n : Entier) : Entier Fonction Factorielle (Don n : Entier) : Entier
-- Prcond : n 0 -- Prcond : n 0
Dbut DefVar
Si (n 1) Rsultat (Entier)
Alors Dbut
Factorielle 1 Rsultat 1
Sinon Pour i de 1 n Faire
Factorielle n * Factorielle (n-1) Rsultat Rsultat * i
Fin Si Fin Pour
Fin Factorielle Rsultat
Fin
Les entiers naturels sont dfinis dune manire rcursive par deux rgles :
0 est un entier naturel.
Le successeur d'un entier naturel est un entier naturel.
La dfinition rcurrente des suites mathmatiques :
U0 = 1
Un = aUn-1 + b
Les chanes de caractres sont dfinies rcursivement -Une chane de caractres est soit :
Une chane vide, soit,
Un caractre suivi d'une chane.
43
UVT
2004
Chapitre 6
La rcursivit
1.2. TYPES DE RECURSIVITE
Il existe deux types de rcursivit :

La rcursivit des objets : Entiers naturels, chanes de caractres,...
La rcursivit des traitements ou des actions : Factorielle, suites,...
Au niveau de ce chapitre, on sintressera la rcursivit des actions, elle se base sur
l'utilisation de la notion de module (procdures et fonctions). Il existe deux types de
rcursivit des actions :
Rcursivit directe : Une action est directement rcursive si son corps prsente un ou
plusieurs appels l'action elle mme.
Figure 6.1 : Rcursivit directe
Module M1 (p_formel1 ; p_formel2)

Dbut
Instruction_1
Instruction_2

M1 (p_rel1, p_rel2) -- Appel du module lui-mme.

Instruction_n
Fin
Rcursivit indirecte : Une action est indirectement rcursive si son excution peut
entraner indirectement un ou plusieurs appels l'action elle mme.
Figure 6.2 : Rcursivit indirecte
Module M1 (p_formel1 ; p_formel2) Module M2 (p_formel3 ; p_formel4)

Dbut Dbut
Instruction_1 instruction_1
Instruction_2
M1 (p_rel1 , p_rel2)
M2 (p_rel3 , p_rel4)

instruction_n instruction_m
Fin Fin
1.3. NOTIONS DE BASE
Exemple : Reprenons lexemple de la fonction Factorielle, on a : n ! = n * (n-1) !.

On peut remarquer que, dans le cas de la rcursivit, il est ncessaire de conserver en mmoire les
expressions intermdiaires non rsolues dans ce quon appelle une pile. Une fois parvenue la
proprit 1! = 1, ces expressions seront dpiles et rsolues.
44
UVT
2004
Chapitre 6
La rcursivit
Analysons la pile en appelant Factorielle (3) :
n=1
n=2 n=2 n=2
n=3 n=3 n=3 n=3 n=3
Etat final
(a) (b) (c) (d) (e)
Etat initial
(a) Premier appel de Factorielle (3), on affecte au paramtre n la valeur 3. Comme (n > 1) on
calcule n * Factorielle (n-1) : n = 3, n-1 = 2 on appelle alors Factorielle (2)
(b) Deuxime appel, n prend la valeur 2, n >1, on appelle Factorielle (1)
(c) Troisime appel, on affecte n la valeur 1, la condition (n>1) nest plus vrifie, donc on
quitte la fonction, on libre la pile de son sommet, on retourne o la fonction Factorielle
(1) a t appele en retournant la valeur 1.
(d) on peut maintenant calculer n * Factorielle (1), n (sommet de la pile) vaut 2, Factorielle
(1) vaut 1, on peut retourner 2, puis on dpile n.
(e) on peut calculer n * Factorielle (2), n vaut 3 (sommet de la pile), Factorielle (2) vaut 2,
3 * 2 = 6, on retourne 6, la pile est vide et retrouve son tat initial.
Notion d'environnement : Il est form par l'ensemble de donnes (variables et

paramtres) utilises par un module lors d'une excution. Chaque fois que le module est
appel rcursivement, un nouvel environnement est gnr, un nouvel ensemble de
variables locales et de paramtres est cr. Bien qu'elles portent le mme nom que
celles cres l'appel prcdent, leurs valeurs sont diffrentes et on utilise toujours le
dernier jeu de variables cr. Cet environnement est dtruit lorsque l'excution prend fin.
Si un module appelle un autre module sans que son excution ne soit termine,
l'environnement du premier est suspendu et il sera ractiv lorsque l'excution du second
sera termine.
Lensemble des environnements existant pour une excution (suspendus ou actif) forme
ce quon appelle une pile denvironnement.
Terminaison : Les traitements engendrs par une dfinition rcursive doivent tre finis
pour que le calcul puisse se terminer. Tout appel rcursif doit donc contenir une clause
conditionnelle telle que l'valuation puisse dans certains cas se faire sans rcursivit.
Dans le cas de la fonction Factorielle(n), la condition darrt est : n 1.
Valeur d'arrt : C'est la valeur pour laquelle les appels rcursifs s'arrtent. Pour le cas
de Factorielle (n), la valeur d'arrt est n = 1.
Profondeur : Dans la plupart des cas, la rcursivit est applique une valeur entire
qui diminue d'une unit chaque excution. Dans ce cas, si on considre fi cette valeur
45
UVT
2004
Chapitre 6
La rcursivit
lors du premier appel et ft cette mme valeur la terminaison, on dit que la rcursivit
est de profondeur (fi ft).
La profondeur indique le nombre de niveaux de rcursivit, cest dire le nombre
denvironnements qui peuvent tre suspendus en mme temps. Par exemple, pour la fonction
Factorielle (3), la profondeur est gale 2.
2) ITERATION OU RECURSIVITE
Une solution rcursive est gnralement plus lente en excution et plus coteuse en
mmoire quune solution itrative. Cependant, elle est souvent plus facile concevoir, et
plus lgante dun point de vue logique et formel, comme par exemple pour le calcul d'une
factorielle.
Si le temps de calcul ou la mmoire utilise sont prohibitifs pour de grands nombres de
donnes, il est toujours possible de traduire un algorithme rcursif en itratif.
Gnralement, la solution rcursive doit tre carte au profit dune solution itrative dans
les cas suivants :
Si la solution itrative est vidente.
Si la profondeur de la rcursivit ne peut pas tre limite.
Si lexcution rcursive entrane des rptitions de traitement quune excution itrative
permet dviter.
La solution rcursive est retenue dans les cas suivants :

Quand l'nonc du problme ou la structure de donnes utilise est rcursif.
Quand il n'y a pas de solution itrative vidente ou meilleure.
2.1. REDONDANCE DES TRAITEMENTS
Dans ce cas, la solution itrative sera retenue bien que la solution rcursive soit vidente.
Voici dans ce qui suit un exemple.
Figure 6.3 : Arbre dexcution (Trace) de la fonction Fibo (4)
46
UVT
2004
Chapitre 6
La rcursivit
Exemple :
La suite de Fibbonacci est dfinie comme suit : Pour viter la redondance de traitements, on
peut envisager lcriture de la version itrative
F(0) = 0, F(1) = 1
de la fonction Fibo :
F(n) = F(n-2) + F(n-1) pour n >1
Fonction Fibo (n : Entier) : Entier
Son algorithme scrit : -- Prcond : n 0
Def Var
Fonction Fibo (n : Entier) : Entier i, x, y, z (Entier)
-- Prcond : n 0 Dbut
Dbut Si (n = 0 Ou n =1) Alors
Si (n = 0 Ou n =1) Alors Fibo n
Fibo n Sinon
Sinon x 0, y 1, i 2
Fibo Fibo (n-2) + Fibo(n-1)
Tant Que (i n) Faire
Fin Si
z x + y,
Fin
xy
yz
ii+1
Fin Tant Que
Fibo z
Fin Si
Fin
2.2. SOLUTION ITERATIVE NON EVIDENTE
Dans ce cas, la solution itrative nest pas vidente, alors que laction est dfinie
rcursivement.
Exemple :
Soit la fonction d'Ackermann dfinie pour Fonction Acker (m,n : Entier) : Rel
tous les entiers non ngatifs m et n de la -- Prcond : m 0 et n 0
manire suivante : Dbut
Si (m = 0) Alors
Acker (0,n) = n + 1 Acker n + 1
Acker (m,0) = Acker (m-1,1) pour m SinonSi (n = 0) Alors
1 Acker Acker (m-1,1)
Acker (m,n) = Acker(m-1, Acker Sinon
(m,n-1)) pour m 1 et n 1 Acker Acker (m-1, Acker (m, n-1))
FinSi
Fin
47
UVT
2004
Chapitre 6
La rcursivit
2.3. DEFINITION DALGORITHMES RECURSIFS
La dfinition des algorithmes rcursifs comporte trois tapes :

Etape 1 : Paramtrage du problme :
On doit faire apparatre tous les paramtres dont la solution dpend.
On doit dfinir la taille du problme rsoudre qui doit dcrotre chaque appel
rcursif.
Etape 2 : Recherche d'un cas trivial ainsi que sa solution : C'est l'tape cl de
l'algorithme.
Etape 3 : Dcomposition du cas gnral : Le but est de ramener le problme un ou
plusieurs problmes de taille infrieure.
3) LE JEU DES TOURS DE HANOI
3.1. DEFINITION DU PROBLEME
Lexemple le plus classique pour illustrer la mthode rcursive est celui des Tours de
Hanoi :
N disques sont empils par ordre de diamtre dcroissant (tous les disques sont de
diamtres diffrents) sur un piquet A. Deux autres piquets B et C peuvent recevoir des
disques, condition que ceux-ci soient toujours empils selon la mme rgle du diamtre
dcroissant. Le but du jeu est de transporter les N disques du piquet A au piquet C, en
utilisant ventuellement le piquet B, tout en respectant les deux rgles suivantes :
Ne dplacer quun seul disque la fois.
Ne placer un disque que sur un disque de diamtre suprieur, ou un piquet libre.
La dmarche rcursive :
Paramtrage du problme :
N : nombre de disques
A, B, C : les piquets (dpart, intermdiaire et arrive)
Recherche de la valeur darrt :

Si (N = 1) Alors Dplacer un disque de A vers C : Dplacer (A, C)
Dcomposition du cas gnral : Rsoudre le problme pour N disques ne prsente pas

de difficult si on sait le rsoudre pour (N-1) disques ; en effet, transporter les N disques
du piquet A au piquet C, cest :
Transporter les (N-1) premiers disques de A vers B (C piquet intermdiaire), puis
Dplacer le disque restant de A vers C, et enfin
Transporter les (N-1) disques de B vers C (A piquet intermdiaire).
48
UVT
2004
Chapitre 6
La rcursivit
3.2. ALGORITHME
Lalgorithmique de la solution se prsente comme suit :
Procdure Hanoi (Don n : Entier ; Don A, B, C : Chane)

-- Prcond : n 1
Dbut
Si (n = 1) Alors
Ecrire ("Dplacer un disque de ", A, " vers ", C)
Sinon
Hanoi (n-1, A, C, B)
Ecrire ("Dplacer un disque de ", A, " vers ", C)
Hanoi (n-1, B, A, C)
Fin Si
Fin
Dans ce qui suit, voici un exemple dexcution de cette procdure pour

Hanoi (3, "Piquet A", "Piquet B", "Piquet C")
Figure 7.4 : Tours de Hanoi : Hanoi(3,A,B,C)
49
UVT
2004
Chapitre 6
La rcursivit
Le nombre de dplacements est une fonction du nombre de disques, en effet :
Si n = 0 nombre de dplacements = 0
...
n 1 nombre de dplacements = 2n - 1
50
UVT
2004
CHAPITRE
LES ALGORITHMES
DE RECHERCHE 7
OBJECTIF
Composer des algorithmes de recherche.
ELEMENTS DE CONTENU
7.1. INTRODUCTION ........................................................................................................... 52

7.1.1. RAPPEL SUR LES TABLEAUX .....................................................................................................52
7.1.2. NOTION DE RECHERCHE ..........................................................................................................52
7.2. RECHERCHE SEQUENTIELLE.................................................................................... 53

7.2.1. RECHERCHE D'UN ELEMENT DANS UN VECTEUR NON TRIE ..........................................................53
7.2.2. RECHERCHE D'UN ELEMENT DANS UN VECTEUR TRIE .................................................................56
7.3. RECHERCHE DICHOTOMIQUE ................................................................................... 56

7.3.1. RAISONNEMENT RECURSIF .......................................................................................................57
7.3.2. RAISONNEMENT ITERATIF .........................................................................................................58
FIGURES
FIGURE 7.1 : DECLARATION DE TABLEAU ............................................................................................... 52

FIGURE 7.2 : FONCTION DE RECHERCHE SEQUENTIELLE RETOURNANT UN BOOLEEN ................................ 53
FIGURE 7.3 : FONCTION DE RECHERCHE SEQUENTIELLE RETOURNANT UN ENTIER.................................... 54
FIGURE 7.4 : FONCTION DE RECHERCHE SEQUENTIELLE RECURSIVE RETOURNANT UN BOOLEEN (1) ......... 55
FIGURE 7.5 : FONCTION DE RECHERCHE SEQUENTIELLE RECURSIVE RETOURNANT UN BOOLEEN (2) ......... 59
FIGURE 7.6 : FONCTION DE RECHERCHE SEQUENTIELLE DANS UN TABLEAU TRIE ...................................... 60
FIGURE 7.7 : FONCTION DE RECHERCHE DICHOTOMIQUE RECURSIVE RETOURNANT UN BOOLEEN.............. 57
FIGURE 7.8 : FONCTION DE RECHERCHE DICHOTOMIQUE ITERATIVE RETOURNANT UN BOOLEEN................ 58
51
UVT
2004
Chapitre 7
Les algorithmes de recherche
1) INTRODUCTION
1.1. RAPPEL SUR LES TABLEAUX
Un tableau est une structure de donnes constitue d'un nombre fixe de composants qui
sont tous de mme type appel type de base. Dans ce qui suit, on va s'intresser aux
tableaux unidimensionnels ou ce qu'on appelle vecteur.
Les oprations possibles sur les tableaux sont :
La lecture (introduction des lments d'un tableau).
L'criture (affichage des lments d'un tableau).
L'affectation (attribution de valeurs aux lments du tableau).
L'accs un lment du tableau se fait par l'indice dfini sur ce tableau.
Exemple : Soit le tableau T dfini de la manire suivante :
Figure 7.1 : Dclaration de tableau
DefConst
dim (Entier) = 100
DefType
Tab = Tableau [1..dim] d'Entier
DefVar
T (Tab)
T[1] est un lment du tableau T. L'accs un lment du tableau se fait en dsignant

l'indice de cet lment. Soit T[i] cet lment, avec 1 i n.
1.2. NOTION DE RECHERCHE
Les algorithmes de recherche quon va laborer se feront sur des tableaux unidimensionnel
(vecteur). Il sagit de chercher un lment dans un tableau, deux situations peuvent se
prsenter :
Soit on connat l'indice de la case o figure llment. Il suffit alors de vrifier que le
contenu est bien celui que l'on recherche.
Soit on connat le contenu de la case mais pas son indice, et ce moment il faut chercher
cet indice.
Il parat vident que la premire recherche est trs simple, cest plutt la deuxime qui sera prsenter
et ceci de deux techniques diffrentes :
Recherche squentielle.
Recherche dichotomique.
52
UVT
2004
Chapitre 7
2) RECHERCHE SEQUENTIELLE
La recherche d'une information est une opration frquemment rencontre dans les
traitements des vecteurs. Le problme pos consiste chercher un lment dans le tableau
condition qu'il soit de mme type que les lments du tableau. Cet lment peut apparatre
zro, une ou plusieurs fois dans le vecteur.
Soient le tableau T dfini prcdemment et un entier E rechercher dans ce tableau. On se

trouve alors devant deux cas possibles :
Cas de recherche squentielle dans un vecteur non tri (non ordonn).
Cas de recherche squentielle dans un vecteur tri (ordonn).
2.1. RECHERCHE D'UN ELEMENT DANS UN VECTEUR NON TRIE

La technique de recherche squentielle d'un lment dans un vecteur non tri consiste passer en
revue les lments jusqu' ce qu'on trouve le bon ou que le vecteur ait t entirement parcouru.
Le traitement se termine dans les deux cas suivants :
Si on trouve l'lment qu'on cherche, et on se contentera dans ce cas de la premire
occurrence de l'lment s'il apparat plusieurs fois dans le tableau.
Si on a parcouru tous les lments du tableau et on n'a pas trouv l'lment recherch.
a)Raisonnement itratif :
Exemple 1 : Soit la fonction R1 qui ralise cette opration de recherche et qui retourne une
valeur boolenne (Vrai si E T &Faux si E T) :
Figure 7.2 : Fonction de recherche squentielle retournant un boolen
Fonction R1 (T : Tab ; N, E : Entier) : Boolen

-- PrCond : T est un tableau dentiers (non tri) de taille N (>0)
-- PostCond : R1 = Vrai si E T, Faux sinon
DefVar
Indice (Entier) -- Indice de parcours
Ok (Boolen)
Dbut
Indice 1
Ok Faux
TantQue (Indice N) Et (Non Ok) Faire
Si (T[Indice] = E)
Alors Ok Vrai
Sinon Indice Indice + 1
FinSi
FinTantQue
R1 Ok
Fin
53
UVT
2004
Chapitre 7
Exemple 2 : Soit la fonction R2 qui recherche un lment dans un tableau et qui retourne sa
position dans le tableau, dfaut -1.
Figure 7.3 : Fonction de recherche squentielle retournant un entier
Fonction R2 (Don T : Tab ; Don N, E : Entier) : Entier

-- PostCond : R2 = p avec T[p] = E et 1<= p <=N, R2 = -1 si E T
DefVar
Pos (Entier) -- Position de llment dans le tableau
(-1 sinon)
Dbut
Indice 1
Pos -1
TantQue (Indice N) Et (Pos = -1) Faire
Si (T[Indice] = E)
Alors Pos Indice
Sinon Indice Indice + 1
FinSi
FinTantQue
R2 Pos
Fin
b) Raisonnement rcursif :
On se propose d'crire la fonction de recherche squentielle dans un tableau non tri d'une
manire rcursive. Pour pouvoir raliser l'appel rcursif, il faut introduire l'indice de parcours
Indice comme paramtre.
Le tableau dans lequel se fait la recherche : soit T.
L'indice de parcours pour donner la position de dbut de la recherche : soit Indice.
La dimension du tableau pour indiquer la position de fin de la recherche : soit N.
L'lment rechercher dans le tableau : soit E.
Recherche de cas trivial :

Lorsque l'indice de parcours Indice dpasse la dimension N du tableau, la recherche se
termine sans trouver l'lment E recherch.
Lorsque T[Indice] = E, la recherche se termine et l'lment est trouv la position
Indice.
54
UVT
2004
Chapitre 7
Rduction du cas gnral :

L'indice de parcours tant initialis 1 au moment du premier appel, ainsi la recherche
s'effectuera sur tout le tableau, soit de 1 N. Au deuxime appel, et si on ne trouve pas
l'lment recherch, la recherche se fera partir du deuxime lment du tableau jusqu' sa
fin. Ainsi, le champ de recherche de l'lment est rduit d'une position chaque appel
rcursif.
Exemple 3 : Soit la fonction rcursive R3 :
Figure 7.4 : Fonction de recherche squentielle rcursive retournant un boolen (1)
Fonction R3 (Don T : Tab ; Don Indice, N, E : Entier) :

Boolen
-- : (1<=Indice<=N) position de dbut de la recherche
Dbut
Si (Indice > N)
Alors R3 Faux
SinonSi (T[Indice] = E)
Alors R3 Vrai
Sinon R3 R3 (T, Indice+1, N, E)
FinSi
Fin
Exemple 4 : Soit la fonction rcursive R4 qui permet de parcourir le vecteur T de droite

gauche sans avoir besoin du paramtre Indice :
Figure 7.5 : Fonction de recherche squentielle rcursive retournant un boolen (2)
Fonction R4 (Don T : Tab ; Don N, E : Entier) : Boolen

Dbut
Si (N = 0)
Alors R4 Faux
SinonSi (T[N] = E)
Alors R4 Vrai
Sinon R4 R4 (T, N-1, E)
FinSi
Fin
55
UVT
2004
Chapitre 7
2.2. RECHERCHE D'UN ELEMENT DANS UN VECTEUR TRIE
Dans une recherche squentielle au niveau d'un tableau tri, le traitement se termine dans
les deux cas suivants :
Si on trouve l'lment qu'on cherche (on se contentera de la premire occurrence de
l'lment s'il apparat plusieurs fois dans le tableau).
Si on a T[Indice]>E (lment recherch). Dans ce cas, on peut tre sr de ne plus
trouver l'lment recherch.
Exemple 5 : Soit la fonction R5 qui permet d'effectuer cette opration de recherche :
Figure 7.6 : Fonction de recherche squentielle dans un tableau tri
Fonction R5 (T : Tab ; N, E : Entier ): Boolen

-- PrCond : T est un tableau dentiers (tri) de taille N (>0)
Def Var
Dbut
Indice 1
Si (E T[N]) Ou (E T[1])
Alors R5 Faux
Sinon
Tant Que (E T[Indice]) Faire
Indice Indice + 1
FinTantQue
Si (T[Indice] = E)
Alors R5 Vrai
Sinon R5 Faux
FinSi
FinSi
Fin
3) RECHERCHE DICHOTOMIQUE
Sur un vecteur dlimit par les indices 1 (BInf) et N (BSup), ordonn de manire croissante,
le principe de recherche dichotomique est le suivant :
On rechercher l'lment situ l'indice Pivot du vecteur (c--d le milieu du vecteur).
On effectue une comparaison entre l'lment recherch et l'lment Pivot :
1. Elment chercher = Elment Pivot : arrt du traitement.
2. Elment chercher Elment Pivot : l'lment chercher est obligatoirement (s'il
existe) dans la partie gauche du vecteur. On rapplique le mme principe en modifiant
la borne suprieure de recherche dans le vecteur (BSup = Indice Pivot 1).
56
UVT
2004
Chapitre 7
3. Elment chercher Elment Pivot : l'lment chercher est obligatoirement (s'il

existe) dans la partie droite du vecteur. On rapplique le mme principe en modifiant la
borne infrieure de recherche dans le vecteur (BInf = Indice Pivot + 1).
3.1. RAISONNEMENT RECURSIF

T : le vecteur des valeurs ordonnes de manire croissante,
BInf : borne infrieure,
BSup : borne suprieure,
E : l'lment rechercher dans le vecteur T,
Le rsultat de la recherche est de type Boolen.
Recherche d'une valeur d'arrt : le processus d'appel rcursif s'arrte dans les 2 cas suivants :
Lorsqu'on trouve l'lment recherch (Position de l'lment),
Ou lorsque la borne infrieure dpasse la borne suprieure (Elment non trouv).
Dcomposition du cas gnral : au moment du premier appel la borne infrieure vaut 1 et la
borne suprieure vaut N. Au deuxime appel, le champ de la recherche est diminu en
positionnant l'lment chercher dans la partie adquate (gauche ou droite).
Exemple 6 : la fonction rcursive R6 permet d'effectuer cette opration de recherche

dichotomique :
Figure 7.7 : Fonction de recherche dichotomique rcursive retournant un boolen
Fonction R6 (T: Tab, BInf: Entier, BSup: Entier,

E: Entier): Boolen
-- 0 BInf BSup
DefVar
Pivot (Entier)
Dbut
Si (BInf > BSup)
Alors R6 Faux
Sinon Pivot (BInf + BSup) Div 2
Si (T[Pivot] = E)
Alors R6 Vrai
SinonSi (T[Pivot] E)
Alors R6 R6 (T, BInf, Pivot-1, E)
Sinon R6 R6 (T, Pivot+1, BSup, E)
FinSi
FinSi
Fin
57
UVT
2004
Chapitre 7
3.2. RAISONNEMENT ITERATIF
Exemple 7 : Soit la fonction itrative R7 qui permet d'effectuer cette opration de recherche
dichotomique :
Figure 7.8 : Fonction de recherche dichotomique itrative retournant un boolen
Fonction R7 (T: Tab, N: Entier, E: Entier): Boolen

DefVar
BInf, BSup, Pivot (Entier) -- pour dlimiter les recherches
Ok (Boolen)
Dbut
Ok Faux
Si (E T[N]) Ou (E T[1])
Alors
BInf 1
BSup N
TantQue (BInf BSup) Et (Non Ok) Faire
-- Ou bien : TantQue (BInf BSup) Et (Ok= Faux) Faire
Pivot (BInf + BSup) Div 2
Si (T[Pivot] = E)
Alors Ok Vrai
SinonSi (T[Pivot] E)
Alors BSup Pivot - 1
Sinon BInf Pivot + 1
FinSi
FinTantQue
FinSi
R7 Ok
Fin
58
UVT
2004
CHAPITRE
LES ALGORITHMES
DE TRI 7
OBJECTIF
Composer des algorithmes de tri.
ELEMENTS DE CONTENU
1. NOTION DE TRI .............................................................................................................. 60

1.1. NOTION DE TRI ........................................................................................................................... 60
1.2. TYPES DE TRI ............................................................................................................................ 60
2. TRI PAR SELECTION ..................................................................................................... 60
2.1. PRINCIPE................................................................................................................................... 60
2.2. ALGORITHME ............................................................................................................................. 61
3. TRI PAR INSERTION ...................................................................................................... 62
3.1. PRINCIPE................................................................................................................................... 62
3.2. ALGORITHME ............................................................................................................................. 63
4. TRI A BULLES (BUBBLE SORT) ................................................................................... 64
4.1. PRINCIPE................................................................................................................................... 64
4.2. ALGORITHME ............................................................................................................................. 65
FIGURES
FIGURE 1 : EXEMPLE D'UTILISATION DE LA METHODE DE TRI PAR SELECTION ............................................... 61

FIGURE 2 : ALGORITHME DE TRI PAR SELECTION........................................................................................ 61
FIGURE 3 : FONCTION DE RECHERCHE DE MINIMUM DANS UN TABLEAU DENTIERS NON TRIE......................... 62
FIGURE 4 : EXEMPLE D'UTILISATION DE LA METHODE DE TRI PAR INSERTION ................................................ 62
FIGURE 5 : ALGORITHME DE TRI PAR INSERTION ........................................................................................ 63
FIGURE 6 : EXEMPLE D'UTILISATION DE LA METHODE DE TRI A BULLES......................................................... 64
FIGURE 7 : ALGORITHME DE TRI A BULLES ................................................................................................. 65
59
UVT
2004
Chapitre 7
Les algorithmes de tri
1) NOTION DE TRI
1.1. NOTION DE TRI
Pour faciliter et acclrer la recherche dun lment quelconque, il est prfrable de garder
en ordre les lments stocks dans une structure de donnes approprie. Il existe une
grande varit dalgorithmes de tri et de recherche (squentielle et dichotomique), et le sujet
a fait lobjet de livres entiers. On dsigne par tri, l'opration qui consiste ordonner un
ensemble d'lments selon un critre bien dtermin ou ce qu'on appelle cl et suivant une
relation d'ordre (ordre croissant ou dcroissant). Il existe deux types de tri :
Tri interne : Il s'effectue sur des donnes prsentes en mmoire centrale, il correspond
gnralement un tri de tableaux.
Tri externe : Il s'effectue sur des donnes rsidentes en mmoire secondaire, il
correspond gnralement un tri de fichiers.
1.2. TYPES DE TRI
Dan ce qui suit, on prsentera seulement les algorithmes de tri les plus connus. Ces
algorithmes qui peuvent tre appliqus sur des tableaux ayant n'importe quel type de base.
Ce qui importe, c'est le critre sur lequel le tableau sera tri.
Le tri par slection : on slectionne un lment particulier et on le spare du reste de la
liste (vecteur). On recommence jusqu obtenir la liste vide.
Le tri par insertion : on insre un par un les lments en les plaant correctement (tri par
insertion squentielle/dichotomique).
Le tri par permutation : on permute les lments qui ne sont pas dans le bon ordre.
Le tri bulles (Bubble Sort).
Le tri rapide ou par segmentation (QuickSort).
Soit le tableau T trier dfini de la manire suivante :

DefConst
dim (Entier) = 100
DefType
Tab = Tableau [1..dim] d'Entier
DefVar
T (Tab)
2) TRI PAR SELECTION
2.1. PRINCIPE
Le principe du tri par slection consiste slectionner l'lment dont la valeur est la plus basse (le
minimum), puis changer la valeur de cet lment avec le premier lment du tableau. Le traitement
se poursuit en cherchant le minimum parmi ceux qui restent : c'est dire partir du deuxime lment
du tableau puis faire l'change avec le deuxime lment jusqu' atteindre T[n-1] et T[n]. la figure
suivante prsente un exemple d'utilisation de cette mthode de tri par slection.
59
UVT
2004
Chapitre 7
Exemple :
Figure 1 : Exemple d'utilisation de la mthode de tri par slection
2.2. ALGORITHME
Figure 2 :Algorithme de tri par slection
Procdure Tri_Slection (Var T : Tab ; Don n : Entier)

-- PrCond : T est un vecteur dentiers non tri. n est la taille du vecteur T (n > 0).
-- PostCond : T est un vecteur tri de taille n. (selon la mthode de tri par slection)
Def Var
i (Entier) -- indice de parcours.
K (Entier) -- indice du plus petit lment.
Min (Entier) -- le plus petit lment (variable intermdiaire).
Dbut
Pour i de 1 (n-1) Faire
k Minimum (T, i, n) -- retourne lindice du plus petit lment du vecteur T[i]..T[N]
Si (T[k] T[i]) Alors -- pas dchange (en cas dgalit)
Min T[k]
T[k] T[i]
T[i] Min
FinSi
FinPour
Fin
59
UVT
2004
Chapitre 7
Figure 3 : Fonction de recherche de minimum dans un tableau dentiers non tri
Fonction Minimum (T : Tab ; Binf, n : Entier) : Entier

-- PrCond : T est un vecteur dentiers (non tri).
-- n est la taille du vecteur T (n > 0).
-- Binf est la borne infrieure du tableau traiter (0 < Binf n)
-- PostCond : Minimum = p, Binf p n
-- p est lindice du plus petit lment se trouvant dans T[Binf..n]
DefVar
i (Entier) -- i : indice de parcours.
m (Entier) -- lindice du plus petit lment.
Dbut
m Binf
Pour i de (Binf+1) n Faire
Si (T[i] T[m]) Alors
m i
FinSi
FinPour
Minimum m
Fin
3) TRI PAR INSERTION
3.1. PRINCIPE
Le principe du tri par insertion consiste placer l'lment T[i] du tableau (2 i n) la bonne place,
c'est dire l'insrer parmi les lments dj ordonns du sous-vecteur T[1..i-1]. Chaque insertion se
fait par comparaisons et dcalages successifs et a pour consquence d'agrandir le sous-vecteur
ordonn d'un lment.
Exemple :
Figure 4 : Exemple d'utilisation de la mthode de tri par insertion
59
UVT
2004
Chapitre 7
3.2. ALGORITHME
Figure 5 : Algorithme de Tri par insertion
Procdure Tri_Insertion (Var T : Tab ; Don N : Entier)

-- PrCond : T est un vecteur dentiers non tri. n est la taille du vecteur T (n > 1).
-- PostCond: T est un vecteur dentiers tri de taille n (tri par insertion)
DefVar
i (Entier) -- indice de parcours.
j (Entier) -- indice de recherche de la bonne place.
Aux (Entier) -- variable intermdiaire contenant llment insrer.
Ok (Logique) -- variable boolenne pour sortir de la boucle TantQue.
Dbut
Pour i de 2 n Faire
Aux T[i]
j i - 1
Ok (Aux < T[j])
TantQue (j 0) Et Ok Faire -- ou bien (j 0) Et Ok = Vrai
Si (Aux T[j])
Alors T[j+1] T[j]
j j - 1
Sinon Ok Faux -- valeur d'arrt
FinSi
FinTant Que
Si (i j+1) Alors
T[j+1] Aux
FinSi
FinPour
Fin
59
UVT
2004
Chapitre 7
4) TRI A BULLES (BUBBLE SORT)
4.1. PRINCIPE
Lide est de faire descendre les lments les plus petits, tandis que les lments les plus
grands remontent. Chaque passe consiste en un parcours squentiel. Durant ce parcours,
on permute les lments conscutifs non ordonns. Le vecteur est tri si lors dune passe on
neffectue aucune permutation.
Exemple :
Figure 6 : Exemple d'utilisation de la mthode de tri bulles
59
UVT
2004
Chapitre 7
4.2. ALGORITHME
Figure 7 :Algorithme de tri bulles
Procdure Tri_Bulles (Var T : Tab ; Don n : Entier)

-- PrCond : T est un vecteur dentiers non tri.
-- n est la taille du vecteur T (n > 1).
-- PostCond : T est un vecteur dentiers tri de taille n (selon la mthode de tri bulles)
DefVar
i, j (Entier) -- indices de parcours.
Aux (Entier) -- variable intermdiaire pour la permutation
Dbut
Pour i de n 2 Pas -1 Faire
Pour j de 2 i Faire
Si (T[j] T[j-1]) Alors
Aux T[j]
T[j] T[j-1]
T[j-1] Aux
FinSi
FinPour
FinPour
Fin
59
UVT
2004
Bibliographie
Bibliographie
Yves Granjon, Algorithmes en Pascal et en C, dition Dunod 1999

ISBN : -10-0004251-3
Claude Delannoy, Exercices en Turbo Pascal, dition Eyrolles 1998

ISBN : 2-212-09045-5
Claude Delonnoy, Initiation la programmation, dition Eyrolles 1996

ISBN : 2-212-01120-2
Jaques Courbin, Initiation lalgorithmique et aux structures de donnes (Volume 1),

dition Dunod, Paris 1994, ISBN : 2-10-004039-1
Bertran Vachon, Bases de la programmation (Cours et exercices corrigs),

dition Ellipses 1992, ISBN : 2-7298-9210-9
Michael Griffits, Algorithmique et programmation, dition Hermes 1992

ISBN : 2-86601-323-9
Patrick Cousot, Algorithmique et programmation en Pascal (Cours),

Patrick Cousot, Algorithmique et programmation en Pascal (Exercices et corrigs)

59
UVT
2004

Cours

Hochgeladen von

Dokumentinformationen

Copyright

Verfügbare Formate

Dieses Dokument teilen

Dokument teilen oder einbetten

Freigabeoptionen

Stufen Sie dieses Dokument als nützlich ein?

Sind diese Inhalte unangemessen?

Copyright:

Verfügbare Formate

Cours

Hochgeladen von

Copyright:

Verfügbare Formate

Algorithmique

& Structures de donnes I

CHAPITRE 1: LES ELEMENTS DE BASE D'UN ALGORITHME

CHAPITRE 2: LES STRUCTURES CONDITIONNELLES

CHAPITRE 3: LES STRUCTURES ITERATIVES

CHAPITRE 4: STRUCTURES DE DONNEES COMPOSEES

CHAPITRE 7: LES ALGORITHMES DE RECHERCHE

Construire des algorithmes structures simples.

1) NOTION DOBJET ALGORITHMIQUE .......................................................................................... 5

FIGURE 1 : STRUCTURE GENERALE DUN ALGORITHME ................................................................................. 6

1) NOTION DOBJET ALGORITHMIQUE

Exemple : On se propose de permuter le contenu de deux objets A et B. Pour ce faire, on aura

1.2. CARACTERISATION DUN OBJET ALGORITHMIQUE

NB : l'identificateur d'un objet algorithmique ne doit pas contenir le caractre Espace.

Exemple : On se propose de reprsenter les objets algorithmiques utiliss dans un problme de

Nom Sens Type Utilisation Nature

2) STRUCTURE GENERALE DUN ALGORITHME

Un algorithme est une suite finie et ordonne doprations lmentaires (instructions ou

Figure 1 : Structure gnrale dun algorithme

-- Auteur : Nom de lauteur

2.1. PARTIE DECLARATIVE

Figure 2 : Dfinition de constante

Figure 3 : Dfinition de type

Figure 4 : Dfinition de variable

2.2. CORPS DE LALGORITHME

3) LES STRUCTURES DE DONNEES SIMPLES

3.1. LES TYPES NUMERIQUES

La priorit dfinie pour ces oprations est la suivante :

3.2. LE TYPE CARACTERE

Les oprations prdfinies relatives au type caractre sont les suivantes:

Voici un extrait de la table Unicode (codes ASCII standards):

Exemples: ASC("7")=55, ASC("'")=39, ASC("\")=92, CHR(55)="7",CHR(39)="'", CHR(92)="\"

3.3. LE TYPE BOOLEEN OU LOGIQUE

Tables de vrit : Soient P et Q deux variables boolennes (logiques)

3.4. LE TYPE SCALAIRE ENUMERE

3.5. LE TYPE INTERVALLE

4) LES INSTRUCTIONS ELEMENTAIRES

4.1. LINSTRUCTION DAFFECTATION

Exemple : Le tableau ci-contre montre les valeurs

4.2. LINSTRUCTION DECRITURE

Ecrire (expression_1, expression_2, ..., expression_n)

Cet algorithme (Ecriture) fournira ces rsultats : 3 15

4.3. LINSTRUCTION DE LECTURE

Figure 7 : Linstruction de lecture

Lire (nom_variable_1, nom_variable_2, ..., nom_variable_n)

Exemple : Cet algorithme permet de lire un nombre et d'crire son carr.

Utiliser les structures dcisionnelles dans la construction des algorithmes.

2) LES STRUCTURES CONDITIONNELLES SIMPLES ...................................................14

3) LES STRUCTURES CONDITIONNELLES GENERALISEES .......................................16

FIGURE 1 : STRUCTURE CONDITIONNELLE SIMPLE A UN SEUL CHOIX ........................................................... 15

1.1. EXEMPLE INTRODUCTIF

1.2. DEFINITION DE CHOIX

2) LES STRUCTURES CONDITIONNELLES SIMPLES

2.1. STRUCTURE CONDITIONNELLE A UN SEUL CHOIX

La structure conditionnelle un seul choix se prsente comme suit :

Figure 1 : Structure conditionnelle simple un seul choix

2.2. STRUCTURE CONDITIONNELLE A DEUX CHOIX

La structure conditionnelle deux choix se prsente comme suit :

Exemple 2: Evaluation d'une expression logique (Prdicat).

3) LES STRUCTURES CONDITIONNELLES GENERALISEES

3.1. STRUCTURES CONDITIONNELLESIMBRIQUEES

Les structures conditionnelles imbriques (ou emboites) se prsentent comme suit :

Exemple : Calcul de remise

3.2. AUTRE FORME GENERALISEE (STRUCTURE SELON)