ALGORITHMIQUE ET STRUCTURES DE DONNEES

CHAPITRE

5
Les structures de contrôle répétitives
 1. Présentation des schémas répétitifs :
Tous les langages de programmation possèdent des structures permettant de répéter un certain
nombre de fois des instructions semblables les unes des autres : les boucles.
Une suite de répétitions délimite une suite ordonnée d’instructions et contrôle le nombre de fois
qu’elle va être exécutée.
On distingue deux types de répétitions :
1- L’Itération : quand on sait le nombre de fois que l’on va répéter une instruction et qu’une
variable compteur peut être initialisée.
2- La Répétition Conditionnelle : quand la poursuite d’une répétition dépend d’une condition
booléenne.

1.1. L’Itération :
Elle permet de répéter N fois une suite ordonnée d’instructions à l’aide d’une variable entière
servant de compteur.

Compt Deb Fin p

Données ? ? ? ?
POUR Compt DE Deb A Fin PAS p FAIRE
Quand Compt > Fin Début
--------------
la répétition s’arrête Instructions
--------------
Fin

A la fin de chaque répétition, Compt est incrémenté d’une quantité p appelée pas
d’incrémentation ( Compt Compt + p), souvent p vaut 1.
Deb est la valeur initiale de Compt et Fin sa valeur finale.
Deb et Fin sont deux constantes entières.

1.2. La répétition conditionnelle :

Elle permet de répéter une suite ordonnée d’instructions tant qu’une condition C est vérifiée. Une
condition peut être composée de plusieurs conditions reliées par les opérateurs logiques (NON,
ET …).

2
 Données ?

TANT QUE <Condition est vraie> FAIRE

Quand la condition Début
--------------
devient fausse Instructions
la répétition s’arrête --------------
Fin

Le corps de la boucle peut ne jamais être exécuté si la condition n’est pas vérifiée dés le début.
Cependant, il existe une autre forme de répétition conditionnelle :

Données ?

REPETER
Quand la condition Début
--------------
devient fausse Instructions
la répétition s’arrête --------------
JUSQU'A <Condition est vraie>

Contrairement à ‘’tant que … faire’’, le corps de la boucle ‘’repeter … jusqu'à’’ s’exécute au

moins une fois.

1.3. Notion d’Assertion :

Trop souvent le programmeur n’a aucune méthode à sa disposition, cela le conduit à oublier
des cas particuliers qui ne seront découverts que lorsqu’il testera son programme.
C’est, entre autres, pour fournir un outil d’aide à la programmation que la notion d’assertion a été
introduite.
Définition : Une assertion est l’affirmation d’une relation vraie entre les valeurs des variables
d’un programme à un instant donné.
Notations :
• Toute assertion sera notée entre accolades.

3
• Pour toute instruction, on distingue la pré_assertion et la post_assertion qui portent
respectivement sur les variables avant et après l’instruction.
{ pré- assertion } Instruction { post- assertion }

Exemple : Supposons l’assertion { P(x) }est vérifiée juste avant une instruction d’incrémentation
de x : { P(x) } x x+1
Pour savoir quelle sera la post_assertion, nous allons raffiner la pré_assertion en
précisant le contenu de la variable x :
{ P(x) } x x + 1 { P(x – 1) }

1.4. Notion de Boucle :

Une boucle est une instruction permettant de répéter l’exécution d’une même séquence un
nombre de fois fini.
Soit un intervalle fini d’entiers i, I = [a, b].
Soit un ensemble séquentiel E = { ei } i appartient à I.
Soit une certaine propriété P que chaque élément de E peut satisfaire ou non. On peut
définir P (ei ) qui signifie que ei satisfait P.

1.5. Invariants de Boucle :

D’une manière générale, la conception d’une boucle consiste en ces points :
Chercher à identifier un indice de boucle : variable entière qui permet de numéroter les
situations successives.
Soit i appartient à l’intervalle [ a, b], le problème de boucle consiste à parcourir un
ensemble séquentiel dont So : situation initiale et Sf : situation finale.
L’instruction à répéter A, est définie par le fait qu’elle permet de passer de la situation Si à
la situation Si+1 : { Si } A { Si+1 }. Les assertions qui caractérisent Si sont appelées
invariants de boucle.
Définition : un invariant d’une boucle d’un algorithme donné est toute assertion qui reste vérifiée
tout au cours de cette boucle.
Soit une instruction itérative I composée à partir de la condition booléenne C, de l’instruction
itérée J et du schéma associé {A et C} J {A}. si le schéma précédent est correct alors le schéma
{A} I {A} est correct. Dans ce cas le schéma complet s’écrit :

4
 {A}
Tant que C faire
{ A et C }
J
{A}
Fin Faire
{A}
L’assertion { A } qui est à la fois pré et post- assertion de l’instruction J est l’invariant de
l’Itération.
La notion d’invariant est essentielle lors de la conception d’un algorithme et tout particulièrement
lorsqu’on veut faire une preuve de programme, c’est- à- dire qu’on veut prouver rigoureusement
qu’un programme fait bien ce pour quoi il a été conçu.

1.6. Conception d’une Boucle par invariant de boucles :

Quatre étapes à suivre pour concevoir une boucle itérative :
1er. Dégager l’indice de boucle et l’invariant de boucle.
2e. Définir le prédicat de contrôle par le fait que sa négation assure la coïncidence de
la situation invariante avec l’objectif (situation finale), ou avec une situation
intermédiaire jugée très proche de l’objectif.
3e. Définir le corps de boucle par le fait que, lorsque le prédicat de contrôle est vrai, il
conserve l’invariant et incrémente (ou décrémente) l’indice de boucle.
4e. Initialiser les variables de façon à respecter l’invariant.

5
 2. Les Schémas Itératifs :
2.1. Le Schéma Itératif POUR :
Rôle : Ce schéma itératif permet l’exécution d’un traitement donné en un nombre de fois n donné.
On peut donc l’utiliser chaque fois qu’on connaît le nombre d’exécutions souhaitées d’un même
traitement (ensemble d’instructions formant le corps de la boucle).
Syntaxe :
[Initialisation]
POUR < nom_var > DE < vi > A < vf > [PAS < pas >] FAIRE
< Traitements >
FINPOUR

< nom_var > : nom de la variable représentant le compteur des itérations à effectuer
< vi > : valeur initiale
< vf > : valeur finale
< pas > : la valeur du pas pour passer de < nom_var > d’une valeur à la suivante.
< Traitements > : un ou plusieurs blocs d’instructions

2.2. Le Schéma Itératif TANT QUE :

Rôle : ce type de schéma permet l’exécution d’un traitement donné, plusieurs fois, tant qu’une
condition spécifiée est vraie. La condition est une expression logique qui peut être simple ou
composée mais qui donne toujours un résultat logique. Par conséquent, ce type de schéma est
utilisé chaque fois que le nombre d’itérations qui seront exécutées n’est pas déterminé à priori.
Syntaxe :
[Initialisation]
TANT QUE < condition > FAIRE
< Traitements >
FINTANTQUE

< Traitements > : un ou plusieurs blocs d’instructions

< Condition > : c’est une condition de travail sous forme d’expression logique qui donne un
résultat logique vrai ou faux.

6
 La réalisation du traitement est directement indépendante de la condition pour entrer dans la
boucle, si la condition est fausse, le traitement ne sera pas exécuté. On peut n’exécuter aucun
parcours dans cette boucle, c’est- à- dire que le traitement peut ne pas être réalisé.

2.3. Le Schéma Itératif REPETER :

Rôle : Ce type de schéma permettra l’exécution d’un traitement donné, plusieurs fois, jusqu’à ce
qu’une condition spécifiée soit vraie. La condition est une expression logique qui peut être simple
ou composée mais qui donne toujours un résultat logique. C’est- à- dire on peut l’utiliser chaque
fois que le nombre d’itérations qui seront exécutées ne peut être déterminé à priori.
Remarque : La différence entre le schéma itératif REPETER et le schéma TANT QUE est que le
traitement spécifié est exécuté au moins une fois dans le premier cas et peut être 0
ou plusieurs fois dans le deuxième cas.
Syntaxe :

[Initialisation]
REPETER
< Traitements >
FINTANTQUE < condition >

< Traitement > : un ou plusieurs blocs d’instructions

< Condition > : c’est une condition d’arrêt sous forme d’expression logique (vrai ou faux).

2.4. Le Schéma Itératif ITERER

Rôle : Ce type de schéma réalisera, plusieurs fois et successivement, l’exécution de deux blocs
d’instructions séparés par une condition, jusqu’à ce que cette condition donne un résultat vraie.
Ce type de schéma est considéré comme celui le plus général puisque les autres types de schéma
ne sont que des cas particuliers de celui- ci.
Syntaxe : [Initialisation]
ITERER
< Traitement1 >
SORTIR SI < condition >
< Traitement2 >
FIN ITERER

7
< traitement1 >, < traitement2 > : deux blocs d’instructions ;
< Condition > : expression logique qui donne un résultat logique vrai ou faux.
Remarques :
1) Si < Bloc 1 > est vide, on aura le schéma sous la forme suivante :
ITERER
TANTQUE < non Condition > FAIRE
SORTIR Si < Condition >
< Bloc 2 >
< traitement2 >
FINTANTQUE
FIN ITERER

2) Si < Bloc 2 > est vide, ce type de schéma aura la forme suivante :

ITERER REPETER
< Bloc 1 > < Bloc 1 >
SORTIR SI < Condition > JUSQU'A < Condition >
FIN ITERER

3. Exemple : Construction d’un algorithme Itératif

La notion d’invariant et des schémas itératifs déjà vus, permet de préparer une méthode
pour construire un algorithme itératif basé sur un raisonnement par récurrence. A l’aide d’un
exemple, on va essayer de montrer la construction de cet algorithme.
Soit à écrire un programme qui, à partir de deux entiers n et p, calcule la valeur np.

* Raisonnement par récurrence :

Supposons que nous ayons déjà partiellement résolu le problème, nous avons une variable r qui
contient la valeur de ni et nous savons que i <= p.
On a donc r = ni , i <= p. Deux possibilités :
Si i = p Alors r = np et le calcul est terminé.
Si i < p Alors nous multiplions r par n en exécutant l’action r := r * n,
r est donc égal à ni * n = ni+1 ; Si nous incrémentons i de 1 en exécutant l’action i := i
+ 1, nous obtenons r = ni , i <= p.

8
L’action itérative s’écrit de la manière suivante :
Tantque i < p Faire
Début
r := r * n ;
i := i + 1 ;
Fin ;
Ici l’assertion est r = ni avec i <= p, c’est aussi l’invariant de boucle, il doit être donc vrai avant
le début de l’itération. Pour cela, il faut initialiser r et i avec des valeurs qui vérifient l’invariant.
* Initialisation :
Il suffit d’écrire les affectations suivantes :
r := n ;
i := 1 ;
Pour vérifier que r = ni , i <= p quelle que soit la valeur de p > 0. A la sortie de l’action itérative,
nous pouvons affirmer que :
• D’une part, Ί (i < p) donc i >= p : condition de sortie de la boucle Tantque.
• De i <= p et i > p, nous déduisons que i = p.
• De i = p et r = ni , nous déduisons que r = np .
* L’algorithme complet est le suivant :
ALGORITHME Puissance
Var n, p, r, i, puissance : entier
Début
r := n ;
i := 1 ;
{ r = ni , i <= p }
TANTQUE i < p FAIRE
Début
r := r * n ;
{ r = ni+1, i < p }
i := i + 1 ;
{ r = ni, i <= p }
Fin ;
{ i >= p, r = ni, i <= p r = np }
puissance := r ;
FinPuissance

9
4. Conclusion :

10