Vous êtes sur la page 1sur 17

Les structures itératives

Définition
• la boucle fait partie des grandes structures de base de
l'algorithmique, et donc de la programmation.
• Les boucles sont des structures itératives. Une itération ou structure
itérative est une séquence d'instructions destinée à être exécutée
plusieurs fois.
• Selon le type de boucle, un bloc d'instructions va être répété un
nombre fixe de fois (n fois) ou selon un certain nombre de critères (un
test de une ou plusieurs conditions)
• Il est possible d'imbriquer plusieurs niveaux de boucles : vous pouvez
faire des boucles dans des boucles, autant de fois que vous le voulez.
Tant Que
La boucle de type "Tant Que" permet la répétition d'un bloc
d'instructions tant que la condition testée est vérifiée, donc vraie.
Sa syntaxe est la suivante : PROGRAMME TQUE1
VAR
Tant Que booléen Faire Cpt: entier
DEBUT
Bloc d'instructions Cpt1
Tant que Cpt<=10 Faire
FinTantQue Afficher Cpt
CptCpt+1
FinTantQue
FIN

Si l'expression booléen devient fausse, alors le programme saute à


l'instruction située juste après le "FinTantQue".
Boucles infinies et "break"
Faites toujours bien attention à ce que votre boucle dispose d'une condition de sortie.
En effet rien ne vous empêche de faire des boucles infinies.
Tant que a=a faire
Afficher cpt
Si cpt=10 alors
break
fin si
cptcpt+1
FinTantQue

La plupart des langages (C, C+ + , Python, Java, PHP, etc.) proposent des instructions
spéciales qui permettent de sortir d'une boucle depuis n'importe quel endroit du bloc
d'instructions (instruction break) ou même de relancer la boucle (remonter directement
au Tant Que) sans exécuter le reste des instructions (instruction continue).
Table de multiplication
PROGRAMME MUTLI1
VAR
table,cpt,résultat : entiers
DEBUT
Afficher "Quelle table de multiplication ?"
Saisir table
Cpt1
Tant que cpt<=10 Faire
Resultatcpt* table
Afficher table,"x",cpt ,"=", résultat
cptcpt+1
FinTantQue
FIN
Une factorielle
PROGRAMME FACT
VAR
cpt,résultat : entiers
DEBUT
Afficher "Quelle factorielle?"
Saisir cpt
Resultatcpt
Tant que cpt>2 Faire
Cptcpt-1
Resultatcpt* Resultat
FinTantQue
101 = 10*9*8*7*6*5*4*3*2*1, soit 3628800
Afficher résultat
FIN
X à la puissance y
PROGRAMME puissance
VAR
x,n,cpt,résultat : entiers
DEBUT
Afficher "x, n ?"
Saisir x,n n
x est égal à x*x*x*x... n fois
cpt1
résultat1
Tant que cpt<=n Faire
resultatresultat*x
cptcpt+1
FinTantQue
Afficher résultat
FIN Et pour les puissances négatives ? x-n est égal à l/xn.
Var x,n,signe,cpt,résultat : entier
Début
Signe0
Afficher "x, n ?"
X à la puissance y (suite)
Saisit x,n
Si n<0 Alors
Signe1
N-n
FinSI
cpt1
Résultat1
Tant que cpt<=n Faire
Resultatrésultat*x
Cptcpt+1
FinTantQue
Si signe=1 Alors
Résultat1/résultat
FinSi
Ecrire résultat
Fin
PROGRAMME MULT12
VAR Toutes les tables
table,cpt,resultat :entiers de multiplication
DEBUT
Table1
Tant Que table<=10 Faire
Afficher "Table des ", table
cpt1
Tant que cpt<=10 Faire
Resultatcpt* table
Afficher table,"x",cpt,"=",resultat
cptcpt+1
FinTantQue
Tabletable+1
FinTantQue
Fin
Var
a, b ,c, nb1, nb2:entier
Trois boucles: intégration
Début
a1 b 1 c 1
avec trois boucles
Tant que a<=100 Faire
Tant que b<=100 Faire
Tant que c<=100 Faire
nb1  a*100+b*10+c
nb2  a3+b3+c3
Si nb1=nb2 Alors
Ecrire nb1,a,b,c
FinSI
c  c+1
FinTantQue Le but de cet algorithme est de trouver pour quelles valeurs
b  b+1 de A, B et C, ABC=A3+B3+C3, A représentant les centaines, B
FinTantQue les dizaines et C les unités. La recherche sera limitée pour
a  a+1 chaque valeur entière comprise entre 1 et 10. L'algorithme
FinTantQue nécessite trois boucles pour chacune des valeurs.
Fin
Répéter ... Jusqu'à
la structure itérative "Tant Que" n'est pas la seule, il en manque encore deux,
dont la structure "Répéter ... Jusqu'à" et "Pour ... Fin Pour".

Son pseudo-code est le suivant :


Répéter Répéter
Bloc d'instructions Bloc d'instructions
Jusqu'à booléen Jusqu'à FAUX
Quoi qu'il arrive, il y aura toujours au moins un passage dans la boucle : le
bloc d'instructions sera exécuté au moins une fois,
L'expression booléenne finale est inversée. Un « tant que a ! = 1 » devient un
"jusqu'à a = 1".
La factorielle
La boucle doit être quittée quand le compteur vaut 2

Var
cpt, résultat : entier
Début
Afficher "Quelle factorielle ?"
Saisir cpt
résultatcpt
Répéter
cptcpt-1
resultatcpt*résultat
Jusqu'à cpt=2
Afficher résultat
Fin
Var
a,b,c,nb1,nb2: entier
Début Les trois boucles
a0 b 0 c 0
Répéter
a  a+1
Répéter
b  b+1
Répéter
c  c+1
nb1  a*100+b*10+c
nb2  a3+b3+c3
Si nb1=nb2 Alors
Ecrire nb1,a,b,c
FinSI
Jusqu'à c=10
Jusqu'à b=10
Jusqu'à a=10
Fin
Pour ... Fin Pour
Troisième et dernière structure itérative de l'algorithmique, le
"Pour ... Fin Pour" est une boucle à l'usage quasi- exclusif des compteurs. À
chaque passage dans la boucle, un compteur est incrémenté ou décrémenté,
selon le cas. On dit alors qu'il s'agit d'une structure incrémentale.
Sa syntaxe en pseudo-code est la suivante :
Pour variable allant De début à fin [PAS pas] Faire Var
Bloc d'instructions cpt : entier
Fin Pour Début
Pour cpt De 1 à 10 Faire
Ou bien
afficher cpt
Pour variable début à fin [PAS pas] Faire
Fin Pour
Bloc d'instructions
Fin
Fin Pour
Il n'existe aucun cas où la structure "Pour ... Fin Pour" est strictement nécessaire. Elle ne fait que simplifier les
autres structures itératives lors de l'utilisation de compteurs.
Un piège à éviter
Ne modifiez jamais un compteur de boucle "Pour" au sein de celle-ci. Si cela s'avère
vraiment nécessaire, modifiez votre boucle pour utiliser une structure "Tant Que"
ou "Répéter".
Voici un exemple de ce qu'il ne faut pas faire :
Var
x :entier
Début
Pour x allant de 1 à 31 Faire
Ecrire x
xx*2
Fin Pour
Fin
Var
a,b,c,nb1,nb2 : entier
Début
De nouveau trois boucles
Pour a de 1 à 10 Faire
Pour b de 1 à 10 Faire L'intérêt est de produire un
Pour c de 1 à 10 Faire code plus succinct et encore
Nb1a*100+b*10+c plus lisible.
Nb2a3+b3+c3
Si nb1=nb2 Alors
Ecrire nb1,a,b,c
FinSI
Fin Pour
Fin Pour
Fin Pour
Fin
La factorielle
Var
cpt, i, résultat : entier Encore un classique : avec une
Début factorielle de n, vous savez à l'avance
Afficher "Quelle factorielle ?" le nombre d'itérations nécessaire : n.
C'est donc une application de choix
Saisir cpt pour la structure "Pour... Fin Pour".
resultat1
Pour i de 2 à cpt
resultat  i*résultat
Fin Pour
Afficher résultat
Fin

Vous aimerez peut-être aussi