Vous êtes sur la page 1sur 12

Chapitre 2 : STRUCTURE D’UN ALGORITHME

1. INTRODUCTION
Le but d’un algorithme étant de décrire un traitement informatique dans quelque chose de
compréhensible par l’humain (et facilement transposable vers la machine), pour qu’un
algorithme soit compréhensible, il faut qu’il soit clair et lisible. Dans ce cas, il existe deux moyens
efficaces :
- soit d’écrire l’algorithme sous forme de texte simple et évident,
- soit de faire un schéma explicatif avec des symboles.
Dans la pratique, les deux formes sont possibles. Il est d’ailleurs courant de commencer par un
schéma, puis quand celui-ci devient trop complexe, de passer à un texte explicatif (la recette).
Dans ce chapitre nous écrirons les algorithmes sous forme de texte structurés.

2. METHODOLOGIE

2.1. Les étapes de résolution d'un problème


Un algorithme résous un problème. Pour mieux cerner la nature et le contenu du problème, il y
a des étapes à suivre. Comprendre l'énoncé du problème en se posant quelques questions :
- De quoi est-il question dans ce problème ?
- Qu’est-ce-qu’on me demande ?
- Quels sont les éléments contenus dans le problème et que je dois utiliser pour résolution ?
- Il y a-t-il un calcul à effectuer (si oui poser la formule du calcul et déduire les éventuelles
variables) ?
- Quelle est la finalité du problème ?

2.2. Décomposer le problème en sous-problèmes plus simple à résoudre


Décomposer le problème en sous-problèmes, c’est décrire les grandes lignes de la résolution du
problème posé. C’est-à-dire pour passer des données aux résultats tout en respectant les
hypothèses de travail. Autrement dit il s’agit d’associer à chaque sous problème une méthode
détaillée décrivant toutes les étapes d’une tâche à accomplir : Les entrées :
- l’élément (ou les éléments) dont on part : éléments de données;
- Le traitement des données : les actions à effectuer sur ces éléments ;
- Les sorties : le (ou les) résultat(s) obtenus.
Il est important de déterminer d’avance le type des entrées et des sorties pour un meilleur
traitement des données.
Résumé. En résumé, on peut retenir que la résolution d’un problème est caractérisée par 4 étapes
:
- Comprendre la nature du problème posé
- Préciser les données fournies (Entrées)
- Préciser les résultats que l’on désire obtenir (Sorties)
- Déterminer le processus de transformation des données en résultats.

1
La plus grande attention doit être portée à la compréhension du problème, faute de quoi
l’algorithme n’a aucune chance d’être correct. Le langage utilisé pour la définition d’un problème
est un langage scientifique utilisant pour des raisons de simplicité une langue naturelle (français par
exemple).

3. STRUCTURE GENERALE D’UN ALGORITHME

3.1. Les éléments d’un algorithme


Un algorithme se caractérise par deux sous-ensembles qui sont : l’ensemble des objets (données
et résultats) et l’ensemble des opérations ou actions.
L’objet désigne une entité du problème. Il est caractérisé par son identificateur (son nom) et par
son titre (l’ensemble des opérations applicables à cet objet). Les actions sont appliquées sur les
données pour produire un résultat.
Ainsi, la structure d’un algorithme se subdivise en trois parties dont l’ordre est à respecter. Les trois
principales parties sont:
▪ L’en-tête : cette partie sert à donner un nom à l’algorithme. Elle est précédée par le mot
Algorithme ;
▪ La partie déclarative : dans cette partie, on déclare les différents objets que l’algorithme
utilise (constantes, variables, etc.) ;
▪ Le corps de l’algorithme : cette partie contient les instructions de l’algorithme. Elle est
délimitée par les mots Début et Fin.
La syntaxe générale d’écriture d’un algorithme est alors la suivante :

En tête Algorithme Nom Algorithme

Partie Constante Identificateur : valeur


déclarative Variable Identificateur : type

DEBUT
Instruction 1
Corps de Instruction 2
l’algorithme ……………….
Instruction n
FIN
Figure 4. Structure d’un algorithme

Remarque. Les mots réservés (ALGORITHME, FONCTION, TANTQUE, POUR, …) sont des
identificateurs prédéfinis du langage algorithmique. Ils ne doivent pas être utilisés
comme identificateur dans un algorithme.
Exemple : syntaxe générale d’un algorithme

Algorithme nom_algorithme
VAR nom_variable : type

2
CONST Nom_constante : valeur
FONCTION nom_fonction() : type
PROCEDURE nom_procédure()
DEBUT
Instruction 1
Instruction 2
……………….
Instruction n
FIN
Remarque. Tous les mots réservés (ou mots clés) sont de préférence mis en majuscule
ainsi que le premier caractère des constantes.

4. FORMAT DES INSTRUCTIONS D’ENTREE ET SORTIE


4.1. Entrées et sorties
Nous disposons d’une instruction de saisie qui permet de récupérer une valeur sur un périphérique
d’entrée (le clavier), et d’une instruction d’affichage qui permet l’édition d’une valeur sur un
périphérique de sortie (l’écran).
Saisir <identification> /* instruction d’entrée*/
Afficher <valeur> /*instruction de sortie*/
Il convient d’afficher des messages permettant de faciliter la communication. Les
instructions saisir et afficher donne un moyen à l’utilisateur de dialoguer avec
l’ordinateur via le clavier et l’écran.
4.2. Opérateurs et expressions
Définition. Un opérateur est un signe qui relie deux variables pour produire un résultat.
Les opérateurs dépendent des types de variables mis en jeu. Pour le type numérique
on a les opérateurs suivants :

+ Addition / Division
- Soustraction ˆ Puissance
* Multiplication % Modulo

Tandis que pour le type chaîne, on a un seul opérateur qui permet de concaténer deux
chaînes de caractères. Cet opérateur de concaténation est noté &.
Par exemple : la chaîne de caractères ″Salut″ concaténer à la chaîne ″tout le monde″
donne comme résultat la chaîne ″Salut tout le monde″.

Définition. Une expression est un ensemble de variables (ou valeurs) reliées par des
opérateurs et dont la valeur du résultat de cette combinaison est unique.
Par exemple :
7 5+4 a + 15 – b/2 nom & prénom
Où a et b sont des variables numériques (réels ou entiers) et nom et prénom sont des
variables chaîne.

3
4.3. L’instruction d’affectation
L’instruction d’affection est une instruction qui consiste à attribuer une valeur à une
variable. On la notera avec le signe « ← ». Cette instruction s’écrit par exemple :
montant ← 405
On dit qu’on affecte (ou on attribue) la valeur 405 à la variable numérique montant.
Si dans une instruction d’affectation, la variable à laquelle on affecte la valeur et la
valeur affectée ont des types différents, cela provoquera une erreur.
On peut aussi attribuer à une variable la valeur d’une variable ou d’une expression de
façon générale. On écrit par exemple :
A←B
A←B*2+5
Syntaxe d’affectation
VAR ← expression
Dans ce cas, l’instruction d’affectation sera exécutée en deux temps :
▪ d’abord, on calcule la valeur de l’expression
▪ On affecte la valeur obtenue à la variable à gauche.
On peut même avoir des cas où la variable de gauche qui figure dans
l’expression à droite. Par exemple :
A←A+5
Dans cet exemple, après l’exécution de l’instruction d’affectation la valeur de la variable
A sera augmentée de 5.

Remarque. Dans une instruction d’affection on a toujours :


▪ à gauche de la flèche d’affection un nom de variable
▪ à droite de la flèche d’affectation une valeur ou une expression
▪ l’expression à droite de la flèche doit être du même type que la variable située
à gauche.
Si dans une instruction d’affectation un de ces points n’est pas respecté, cela
engendrera une erreur. Il est à noter que l’ordre dans lequel sont écrites les instructions
est essentiel dans le résultat final

Exemple 1. Ecrire un algorithme qui demande deux nombres entiers à l'utilisateur, puis qui calcule
et affiche la somme de ces nombres.

4
A B S

3 6 9

Algorithme Calcul_double
VAR A, B, S : ENTIER
DEBUT
Afficher ("entrer les nombres A et B ") /* demande d’entrer un nombre sur l’écran*/
saisir (A,B) /* Entrée au clavier un nombre */
S ← A+B
Afficher ("la somme de ", A, ‘’et’’, B, "est :", S)
FIN
Dans un algorithme, les instructions s’exécutent séquentiellement les unes après les
autres, dans l’ordre où elles apparaissent. Il est important de bien définir chaque
instruction.
Exemple 2. Ecrire un algorithme qui échange deux nombres stockés.
Algorithme echange_stockage
VAR a : ENTIER
VAR b : ENTIER
VAR tamp : ENTIER /* variable tampon de stockage */
DEBUT
tamp ← a /* on sauvegarde a dans la variable tamp */
a← b
b ← tamp
FIN
Remarques. Dans l’exemple 2, les variables sont déclarées une à une en revenant à la ligne pour
chaque déclaration. Dans l’exemple 1, les variables sont déclarées sur une seule ligne. Ces deux
algorithmes sont corrects. Il est important de noter que la déclaration de plusieurs variables sur
une même ligne est possible si elles ont le type.
Les textes entre les symboles ‘’/*,’’ et ‘’ */ ‘’ sont des commentaires qui expliquent la ligne (ou
l’instruction) à gauche. Ce n’est donc pas une instruction à exécuter.

5. LA STRUCTURE ALTERNATIVE
5.1. Les conditions simples
Une condition simple consiste en une comparaison entre deux expressions du même
type. Cette comparaison s'effectue avec des opérateurs de comparaison. Voici la liste
de ces opérateurs accompagnés de leur signification dans le cas des types numérique
ou chaîne :

5
Signification Signification chaîne
Opérateur
numérique
= égal à égal à
<> différent différent
< inférieur placé avant dans l'ordre alphabétique
> supérieur placé après dans l'ordre alphabétique
<= inférieur ou égal placé avant dans l'ordre alphabétique ou
>= supérieur ou égal égal
placé après dans l'ordre alphabétique ou
égal
Pour la comparaison du type chaîne c'est l'ordre alphabétique qui est utilisé dans le
cas où l'on compare deux lettres majuscules ou minuscules. Mais si l'on compare
majuscules et minuscules, il faut savoir que les majuscules apparaissent avant les
minuscules. Ainsi, par exemple : "M" < "m".
5.2. Les conditions complexes
Certains problèmes exigent parfois de formuler des conditions qui ne peuvent pas être
exprimées sous la forme simple vu en dessus. A cet effet, la plupart des langages
autorisent des conditions formées de plusieurs conditions simples reliées entre elles
par ce qu'on appelle des opérateurs logiques. Ces opérateurs sont : ET, OU et NON.
▪ Pour que la condition complexe,
condition1 ET condition2 soit VRAI,
il faut impérativement que la condition1 soit VRAI et que la condition2 soit VRAI.
▪ Pour que la condition,
condition1 OU condition2 soit VRAI,
il suffit que condition1 soit VRAI ou condition2 soit VRAI.
Il est à noter que cette condition complexe sera VRAI si condition1 et condition2 sont
VRAI.
▪ Le NON inverse une condition,
NON (condition) est VRAI,
si condition est FAUX, et il sera FAUX si condition est VRAI.
Remarque. D'une manière générale, les opérateurs logiques peuvent porter, non
seulement sur des conditions simples, mais aussi sur des conditions complexes.
L'usage de parenthèses permet dans de tels cas de régler d'éventuels problèmes de
priorité. Par exemple, la condition :
(a < 0 ET b > 1) OU (a > 0 ET b > 3)
est VRAI si l'une au moins des conditions entre parenthèses est VRAI.
5.3. La structure alternative
Supposons que nous avons besoin, dans un algorithme, d'afficher un message
précisant que la valeur d'une variable est positive ou négative. Avec les instructions
de base que nous avons vu (celles qui permettent la manipulation des variables :

6
affectation, afficher, saisir), on ne peut pas. Il faut introduire une des instructions de
structuration du programme (ces instructions servent à préciser comment doivent
s'enchaîner chronologiquement ces instructions de base) qui donne la possibilité
d'effectuer des choix dans le traitement réalisé. Cette instruction s'appelle la
structure alternative.
Un algorithme doit donc donner la possibilité d’effectuer des choix, autrement dit
d’avoir des comportements qui puissent dépendre des résultats intermédiaires. On
parle dans ce cas de structure conditionnelle.
5.4. La structure alternative simple
On peut demander à un algorithme de n’exécuter des instructions que si une
certaine condition est remplie.

vraie
FORMAT GENERAL condition
SI<condition>ALORS
<séquence1> séquence
faux
FSI

Si la condition mentionnée après SI est VRAI, on exécute le bloc1 d'instructions


(ce qui figure après le mot ALORS).
L’expression <condition> est une expression logique dont le résultat est un booléen
(VRAI ou FAUX).
▪ la condition est évaluée ;
▪ si la condition est vraie, la séquence est exécutée puis le contrôle passe à
l’instruction qui suit le FSI (Fin de Si) ;
▪ si la condition est fausse, le contrôle passe à l’instruction qui suit le FSi.
En d’autres termes, la séquence est exécutée si et seulement si la condition est VRAI.
Exercice. Ecrire un algorithme qui affiche la valeur absolue de la différence entre 2
nombres saisis au clavier.
5.5. La structure alternative complexe
Dans ce cas on ajoute un traitement à exécuter si la condition n’est pas vérifiée.

SI <condition> ALORS

SINON

Si la condition mentionnée après SI est VRAI, on exécute le bloc1 d'instructions (ce


qui figure après le mot ALORS); si la condition est fausse, on exécute le bloc2
d'instructions (ce qui figure après le mot SINON).

7
Remarque : Il est recommandé de faire apparaître sous forme de commentaire la
condition associée à la partie Sinon.
Exercice. Ecrire un algorithme qui vérifie si une note est comprise entre 0 et 20.
5.6. Les structures alternatives imbriquées
Il peut arriver que l'une des parties d'une structure alternative contienne à son tour une
structure alternative. Dans ce cas, on dit qu'on a des structures alternatives imbriquées les
unes dans les autres.

SI <condition1> ALORS

SINON SI <condition2> ALORS

FSI

SINON

Évaluation : Les conditions sont évaluées dans l’ordre d’apparition. Dès qu’une condition est
vraie, la séquence associée est exécutée. L’instruction suivante à exécuter sera alors celle qui
suit le FinSi. Si aucune condition n’est vérifiée, alors la séquence associée au Sinon, si elle
existe, est exécutée.
Exercice. Signe d’un entier Étant donné un entier lu au clavier, indiqué s’il est nul, positif ou
négatif.
5.7. La structure selon
La structure Selon permet de choisir le traitement à effectuer en fonction de la valeur ou de
l’intervalle de valeur d’une variable ou d’une expression. Cette structure permet de
remplacer avantageusement une succession de structures Si . . . Alors.

Syntaxe de la structure selon


SELON <expression> FAIRE
<Valeur 1> : séquence 1 ;
<valeur 2> : séquence 2 ;
<valeur 3> : séquence 3 ;
[SINON <séquence par défaut>]
FINSELON
Règles :
▪ Expression est nécessairement une expression de type scalaire.
▪ choixi est une liste de choix séparés par des virgules. Chaque choix est soit
une constante, soit un intervalle (10..20, par exemple).
L’instruction Selon peut donc être considérée comme un cas particulier de la
conditionnelle Si ... SinonSi ... FinSi.

8
Évaluation : L’expression est évaluée, puis sa valeur est successivement comparée à
chacun des ensembles choix. Dès qu’il y a correspondance, les comparaisons sont
arrêtées et la séquence associée est exécutée. Les différents choix sont donc
exclusifs. Si aucun choix ne correspondant, alors la séquence associée au Sinon, si
elle existe, est exécutée.
Remarque : La clause Sinon est optionnelle... mais il faut être sûr de traiter tous les
cas (toutes les valeurs possibles de l’expression).
Exercice. Écrire un programme qui demande à l’utilisateur de saisir un caractère et
qui affiche « affirmatif » si le caractère est un « o » (minuscule ou majuscule), «
négatif » si c’est un « n » (minuscule ou majuscule) et « ? ! ? ! ? ! ? » dans les autres
cas.
Les structures conditionnelles permettent d’enrichir le traitement séquentiel d’un
algorithme en donnant la possibilité d’exécuter un ensemble d’instructions relatif à
une certaine condition.
5.8. Les structures répétitives
Reprenons le programme du surveillant général qui calcule la moyenne des notes.
L’exécution de ce programme fournit la moyenne des notes uniquement pour un seul élève.
S’il l’on veut les moyennes de 200 élèves, il faut ré exécuter ce programme 200 fois. Afin
d’éviter cette tâche fastidieux d’avoir ré exécuter le programme 200 fois, on peut faire
recourt à ce qu’on appelle les structures répétitives. On dit aussi les structures itératives ou
boucles.
Une structure répétitive sert à répéter un ensemble d’instructions. Il existe trois formes de
structures répétitives : POUR, TANT QUE, REPETER.
Supposons qu’on veuille afficher les 10 premiers entiers positifs. Si on utilise le
traitement séquentiel on aura l’algorithme suivant :

ALGORITHME affiche
VAR
DEBUT
Ecrire(0) ;
Ecrire(1) ;
Ecrire(2) ;
Ecrire(9);
FIN
Cette méthode reste raisonnable pour un petit nombre mais si on veut afficher les n
premiers entiers avec n = 1000, l’algorithme devient alors absurde et impossible à
écrire. Pour pouvoir écrire un tel algorithme, on aura besoin d’une structure qui permet
de répéter automatiquement une instruction ou un groupe d’instructions. On doit alors
utiliser des structures itératives (appelé également structure répétitives).
Une structure itérative est une structure qui répète un même traitement autant de fois
que l’on veut pour vue que la condition d’exécution soit satisfaite. Cette boucle s’arrête
lorsque cette condition n’est plus vérifiée. Il existe trois schémas (boucles) de

9
représentation d’une structure itérative à savoir :
▪ la boucle Tant que
▪ la boucle Répéter
▪ la boucle Pour
L’étude de cette structure est l’objet de la section ci-dessous.
5.9. La structure itérative: les boucles

Cette structure permet la répétition d’une (ou plusieurs) action(s) tant qu’une condition est
satisfaite. La condition est testée avant la première exécution de l’action définie. Il est important
de cherche la condition d’arrêt du traitement.
La boucle TANT QUE exécute un traitement tant qu’une condition est VRAIE.

syntaxe
TANTQUE <condition> FAIRE
< séquence>
FTANTQUE

Règles :
- La condition doit être une expression booléenne.
- Pour que la boucle se termine, il est nécessaire que la séquence modifie la
condition.
Évaluation : La condition est évaluée. Si elle vaut FAUX alors la boucle se termine et
l’exécution se poursuit avec l’instruction qui suit FinTQ. Si elle vaut VRAI alors la
séquence d’instructions est exécutée et la condition est de nouveau évaluée.
5.10. La structure POUR
La boucle Pour est une structure répétitive qui itère le même traitement pour une
plage de valeurs entières comprises entre une borne inférieure et une borne
supérieure. L’arrêt du traitement de la boucle Pour se réalise lorsqu’on dépasse l’une
des bornes.
syntaxe :
POUR <compteur> DE <borne_inférieure> À <borne_supérieure> PAS
<incrément> FAIRE <traitement>
FPOUR
avec
<compteur> variable de type entier.
<borne_inférieure> valeur de type entier.
<borne_supérieure> valeur de type entier.
<incrément> valeur de type entier.

10
Intialisation

condition de non
continuité vraie

oui

Bloc d'itération

modification

suite du
programme

Remarque. Ne modifier jamais la valeur du compteur dans une instruction Pour.


- si on ne spécifie pas la valeur du PAS dans l’instruction POUR il prends par
défaut la valeur
- si <borne_inférieure> < <borne_supérieure>
- si <borne_inférieure> > <borne_supérieure>

Exercice. Affichage des N premiers entiers.


Règle :
- La variable var est une variable d’un type scalaire. Elle est dite variable de
contrôle.
- Les expressions val _ min et val_ max sont d’un type compatible avec celui de
var.
- La séquence d’instructions ne doit pas modifier la valeur de la variable var.
Évaluation : Les expressions val _ min et val_max sont évaluées. La variable var prend
alors successivement chacune des valeurs de l’intervalle [val min..val _ max] dans
l’ordre indiqué et pour chaque valeur, la séquence est exécutée.
Remarque. L’incrémentation est la valeur d’augmentation progressive de
l’identificateur. La valeur par défaut du pas est de 1 (Dans ce cas il n’est pas
nécessaire de le préciser).
 Si la valeur initiale est égale à la valeur finale, l’action définie est exécutée
une seule fois.
 Si la valeur de l’incrément est positive et la valeur initiale strictement
supérieur à la valeur finale alors l’action définie dans la structure POUR n’est
pas exécutée.
 Si la valeur de l’incrémentation est négative et la valeur initiale strictement
inférieur à la valeur finale alors l’action définie dans la structure POUR n’est
pas exécutée.

- Cette structure est utilisée lorsqu’on connaît à l’avance le nombre d’itérations


à faire.
- Les expressions val _ min et val max ne sont évaluées qu’une seule fois.
- La séquence peut ne pas être exécutée (intervalle vide : val _ min > val max).
- La séquence termine nécessairement (le variant est val _ max - var + 1).

11
Attention : Il est interdit de modifier la valeur de la variable de contrôle var dans la
boucle.
Remarque : Il n’y a pas d’équivalent du Pour dans les organigrammes. On peut
utiliser la traduction du Pour sous forme de TantQue ou de Répéter.
5.11. La structure répétitive

La boucle Répéter permet de rentrer dans la boucle quel que soit la condition et réitère
l’exécution jusqu’à ce que la condition soit vérifiée.

NB :
- Dans une boucle Répéter, le traitement est exécuté au moins une fois quelle que soit
la valeur de la condition d’arrêt.
- Dans une boucle Répéter, on parle de condition d’arrêt. Quand la condition
d’arrêt est atteinte (<condition> prend la valeur vrai), on sort de cette boucle.

Syntaxe
Répéter
<séquence>
jqà (<condition>)

Remarques. On ne peut utiliser la boucle Pour que si on connaità prioris le


nombre d’itérations.
• la condition n’est évaluée qu’après l’exécution de la séquence ;
• la séquence est exécutée au moins une fois ;
• la condition doit être modifiée par la séquence ;

Choix de la structure (TantQue, Pour, Repeter … jusqu’à)

• Si on peut déterminer le nombre d'itérations avant l'exécution de la boucle, il


est plus naturel d'utiliser la boucle Pour
• S'il n'est pas possible de connaître le nombre d'itérations avant l'exécution de
la boucle, on fera appel à l'une des boucles TantQue ou répéter jusqu'à
• Pour le choix entre TantQue et jusqu'à :
• Si on doit tester la condition de contrôle avant de commencer les
instructions de la boucle, on utilisera TantQue
Si la valeur de la condition de contrôle dépend d'une première exécution des
instructions de la boucle, on utilisera répéter jusqu'à.

12

Vous aimerez peut-être aussi