UA 7 : Ecrire et exécuter des algorithmes intégrant une structure

de données
Compétence : A l’aide des notions et des acquis qu’il aura reçu, l’apprenant sera capable de
mobiliser des ressources numériques pour écrire et exécuter un algorithme à la main.

UE 12 : Les structures de contrôle et structures de données

Exemples d’actions :
 Décrire les structures de contrôle ;
 Citer cinq structures de données ;
 Déclarer un tableau ;
 Parcourir un tableau pour effectuer la lecture et l’affichage.

Introduction
Les opérations élémentaires relatives à la résolution d‘un problème, peuvent
en fonction de leur enchainement, être organisées suivant une famille de structures
algorithmiques fondamentales. nous pouvons citer :
 La structure séquentielle ;
 La structure alternative ou de choix ;
 La structure itérative ou répétitive.

I. Les structures de contrôle

1) La structure séquentielle
Une structure séquentielle est une structure dont les instructions s’exécutent les unes
après les autres dans un autre bien défini.
Syntaxe :
Début
Instruction 1 ;
Instruction 2 ;
…….
Instruction n ;
Fin

Exemple : Ecrire l’algorithme qui calcul la moyenne de deux entiers.

Solution
Algorithme Moyenne_notes
Variables note1, note2, moy : Réel ;
Début
Ecrire(‘’Entrez la première note’’) ;
Lire(note1) ;
Ecrire(‘’Entrez la deuxième note’’) ;
Lire(note2) ;
moy ← (note1+note2)/2 ;
 Ecrire(‘’La moyenne des notes est : ‘’ moy);
Fin

2) Les structures alternatives ou de choix

L‘instruction si permet de programmer une structure dite de choix (ou alternative),
permettant de choisir entre deux instructions ou plus, suivant la valeur d‘une expression jouant
le rôle de condition. Elle est introduite par le mot clé SI. La seconde partie, introduite par le mot
clé SINON, est facultative, de sorte que l‘instruction SI présente deux formes. On distingue deux
types de structures alternatives :
 La structure alternative réduite ;
 La structure alternative complète.

a) La structure alternative réduite

Sa syntaxe est la suivante :
Si (condition) alors
Action ;
Finsi

Exemple : vérifions si un nombre est nul ou pas

Afficher (‘’entrer un nombre quelconque :’’) ;
Saisir (nombre) ;
Si (nombre = 0) alors
Afficher (‘’NULLE‘’) ;
Finsi

b) La structure alternative complète

Dans cette structure l‘exécution d‘un des deux traitements distincts ne dépend que du
résultat d‘un test effectué sur la condition qui peut être une variable ou un évènement. Sa
syntaxe est La suivante :
Si (condition) alors
action1 ;
Sinon
action2 ;
Finsi

Ceci signifie que :

 Le test de la condition est effectué ;
 Si le test est positif, action1 est exécuté ;
 Si le test est négatif, action2 est exécuté ;
 Sortir de la structure.

Exemple : Ecrire qui vérifie et informe en fonction de l’âge de saisi si on peut déjà voter ou pas.
 Algorithme electeur
Variables age : Entier ;
Début
Ecrire(‘’Entrez votre age’’) ;
Lire(age) ;
Si (age>=20) alors
Ecrire(‘’Vous pouvez être électeur’’) ;
Sinon
Ecrire(‘’Vous ne pouvez pas être électeur’’) ;
FinSi
Fin

3) Les structures itératives ou répétitives

La structure itérative ou boucle répète l‘exécution d‘une instruction ou d‘un ensemble
d‘instructions. Sa forme dépend de la connaissance qu‘on a du nombre de répétition de L‘action.
On distingue deux cas :
 le nombre de répétition n’est pas connu ;
 le nombre de répétition est connu.

a) Le nombre de répétitions n‘est pas connu ou est variable

On distingue deux structures de bases :
La structure RÉPÉTER JUSQU’A
La structure TANT QUE FAIRE

Structures Description Syntaxe

Dans la structure REPETER Répéter
…JUSQU'A, l‘action est exécutée une Action ;
REPETER…JUSQU’A première fois puis sa répétition se Jusqu‘à condition vrai
poursuit jusqu‘à ce que la condition
soit vérifiée.
Dans la structure TANT TANT QUE condition
QUE…FAIRE, la condition est testée Faire
TANT QUE…FAIRE
avant d’exécuter l’action Action ;
FIN TANT QUE

Exemple : Somme des nombres inférieurs ou égal à 20.

TANT QUE…FAIRE REPETER…JUSQU’A
S ← 0 ; S ← 0 ;
i ← 1 ; i ← 1 ;
TantQue (i<=20) faire
Répéter
S ← S+i ;
i ← i+1 ; S ← S+i ;
FinTantQue i ← i+1 ;
Jusqu’à (i<=20)
FinRépeter
 b) Le nombre de répétitions est connu
On utilise la structure POUR.
Syntaxe :
Pour indice allant de v1 à v2 pas n faire
action ;
fin pour

 Où indice représente le compteur et s’incrémente en fonction du pas.

 Lorsque le pas n’est pas précisé, il vaut 1.
 Si v1 < v2, on parle de pour croissant et si v1 > v2 , on parle de pour décroissant.

Exemple : Affichons les 10 premiers nombre pairs.

Solution 1 :
Pour i allant de 0 à 20 pas de 2 faire
Ecrire(i) ;
FinPour

Solution 2 :
Pour i allant de 0 à 20 faire
Si (i%2=0) alors
Ecrire(i) ;
FinSi
FinPour

Exercice : On souhaite calculer la somme des nombres pairs compris entre 1 et 100. Utilisez les
structures itératives pour écrire l’algorithme qui résout ce problème.
TANT QUE…FAIRE Pour
Algorithme Somme_nombre Algorithme Somme_nombre
Variable i, S : Entier ; Variable i, S : Entier ;
Début Début
S ← 0 ; S ← 0 ;
i ← 1 ; Pour i allant de 1 à 100
TantQue (i<=100) faire faire
Si (i%2=0) alors Si (i%2=0) alors
S ← S+i ; S ← S+i ;
FinSi FinSi
i ← i+1 ; FinPour
 FinTantQue Ecrire(‘’La somme calculée
Ecrire(‘’La somme calculée est : ’’ S) ;
est : ’’ S) ; Fin
Fin

II. Les structures de données

En informatique, une structure de données est une manière d'organiser les données pour
les traiter plus facilement. Une structure de données est une mise en œuvre concrète d'un
type abstrait. Les types de données classiques étant limités pour certains traitement, une
nécessité a donc été constaté de créer d’autres types de données qui vont satisfaire ces
insuffisances. D’où l’utilité des structures de données.

1) Tableaux
Un tableau est une structure de données représentant une séquence finie d'éléments de
même nature auxquels on peut accéder efficacement par leur position, ou indice, dans la
séquence.
C'est un type de conteneur que l'on retrouve dans un grand nombre de langages de
programmation.
Un tableau ressemble à ceci :

Données Val1 Val2 Val3 Val4 Val5 Val6 Val7

Indice 0 1 2 3 4 5 6

2) Enregistrement
Contrairement aux tableaux qui sont des structures de données dont tous les éléments
sont de même type, les enregistrements sont des structures de données dont les éléments
peuvent être de différents types et qui se rapportent à la même entité sémantique. Les éléments
qui composent un enregistrement sont appelés champs. Avant de déclarer une variable
enregistrement, il faut avoir au préalable définit son type, c’est à dire le nom et le type des
champs qui le composent. Le type d’un enregistrement est appelé type structuré. (Les
enregistrements sont parfois appelé structures, en analogie avec le langage C).

Syntaxe :

NomEnregistrement = Enregistrement
NomChamp1 : TypeChamp1
NomChamp2 : TypeChamp2
...
NomChampn : TypeChampn
Fin Enreg

Exemples

Enregistrement d’une Enregistrement d’une Enregistrement d’un

personne date point

Personne = Enregistrement Date = Enregistrement Point = Enregistrement

Nom : Chaîne Jour : Entier Num : Entier
Prénom : Chaîne Mois : Entier Abscisse : Réel
Age : Entier Année : Entier Ordonnée : Réel
 Fin Enreg Fin Enreg Fin Enreg

3) Pile
Une pile (en anglais stack) est une structure de données permettant des insertions ou des
suppressions qu’a une seule extrémité, appelée sommet de la pile.
Elle est fondée sur le principe « dernier arrivé, premier sorti » (en anglais LIFO pour last
in, first out), ce qui veut dire, qu'en général, le dernier élément, ajouté à la pile, sera le premier à
en sortir.
Quand on vous dit pile penser directement à une boite d’Efferalgan.
Empiler un objet sur une pile P consiste à insérer cet objet au sommet de P (dans la pile
d’assiettes une nouvelle assiette ne peut être ajoutée qu’au-dessus de celle qui se trouve au
sommet).
Dépiler un objet de P consiste à supprimer de P l'objet placé au sommet (dans la pile
d’assiettes seule peut être retirée celle qui se trouve au sommet).
La manipulation d’une pile revient à l’appel de fonctions et procédures dites de bases
définies une seule fois et utilisées autant de fois qu’il est nécessaire. Ces sous-algorithmes sont :
- Init_Pile : permet d’initialiser une pile à vide lors de sa création ;
- Pile_vide : pour vérifier si une pile est vide ou non et savoir alors s’il reste des valeurs à
traiter ou non ;
- Pile_pleine : pour vérifier s’il est possible de rajouter ou non un nouvel élément (utilisée
dans le seul cas des piles statiques) ;
- Empiler : permet d’ajouter une nouvelle valeur (envoyé en paramètre par l’appelant) à la
pile (au-dessus du sommet et dans le cas d’une pile non pleine) ;
- Depiler : permet de supprimer une valeur (se trouvant au sommet de la pile) et de la
renvoyer en paramètre. Cette opération n’est possible que si la file n’est pas vide.

4) File
Une file dite aussi file d'attente (en anglais queue), est une structure de données basée sur le
principe du premier entré, premier sorti ou PEPS, (en anglais FIFO (« first in, first out ») ce qui
veut dire que les premiers éléments ajoutés à la file seront les premiers à en être retirés.
Quand on vous dit file penser directement à une file d’attente où chacun à son tour qu’il doit
respecter.
 Enfiler un objet sur une file F consiste à insérer cet objet à la fin de la file F (dans la file
d’attente un nouvel arrivant se met à la queue c.-à-d., après la personne arrivée juste avant lui) ;
Défiler un objet de F consiste à supprimer de F l'objet placé en début de file (dans la file
d’attente seule peut être servie la personne qui se trouve en début de file). L'objet défilé est
retourné comme résultat du traitement. En informatique une file sert essentiellement à stocker
des données qui doivent être traitées selon leur ordre d’arrivée. L’exemple le plus connu est celui
de l’impression de documents reçus par une imprimante qui imprime le premier document
arrivé et termine par le dernier. Ce qui fait que les objets quittent la pile dans l'ordre de leur
ordre d'arrivée.
Comme pour les piles, la manipulation d’une file revient à l’appel de fonctions et procédures
dites de bases définies une seule fois et utilisées autant de fois qu’il est nécessaire. Ces sous-
algorithmes sont :
- Init_File : permet d’initialiser une file à vide lors de sa création ;
- File_vide : pour vérifier si une file est vide ou non et savoir alors s’il reste des valeurs à
traiter ou non ;
- File_pleine : pour vérifier s’il est possible de rajouter ou non un nouveau élément (utilisée
dans le seul cas des files statiques) ;
- Enfiler : permet d’ajouter une nouvelle valeur (envoyé en paramètre par l’appelant) à la
file (après le dernier élément de la file qui se trouve au niveau de sa queue et dans le cas d’une
file non pleine) ;
- Defiler : permet de supprimer une valeur (se trouvant au début de la file) et de la renvoyer
en paramètre. Cette opération n’est possible que si la file n’est pas vide.

Premier arrivé Dernier arrivé

Premier Servi Dernier Servi

5) Listes
Une liste est une structure de données permettant de regrouper des données de manière
à pouvoir y accéder librement (contrairement aux files et aux piles, dont l'accès se fait
respectivement en mode FIFO et LIFO).
Il n'existe pas de normalisation pour les primitives de manipulation de listes, leurs noms
respectifs sont donc indiqués de manière informelle.
Primitives de base :
« Insérer » : ajoute un élément dans la liste. Terme anglais correspondant : « Add » ;
« Retirer » : retire un élément de la liste. Terme anglais correspondant : « Remove » ;
« La liste est-elle vide ? » : renvoie « vrai » si la liste est vide, « faux » sinon. Terme
anglais correspondant : « IsNil » ;
« Nombre d'éléments dans la liste » : renvoie le nombre d'éléments dans la liste. Terme
anglais correspondant : « Length ».
Primitives auxiliaires fréquemment rencontrées :
« Premier » : retourne le premier élément dans la liste. Terme anglais correspondant : «
First » ;
 « Dernier » : retourne le dernier élément dans la liste. Terme anglais correspondant : «
Last » ;
« Prochain » : retourne le prochain élément dans la liste. Terme anglais correspondant :
« Next » ;
« Précédent » : retourne l'élément qui précède dans la liste. Terme anglais correspondant
: « Previous » ;
« Cherche » : cherche si un élément précis est contenu dans la liste et retourne sa position.
Terme anglais correspondant : « Find ».

III. Manipulation des tableaux

1) Déclarer un tableau
La déclaration d‘un tableau se fait de la manière suivante :
Nom_tableau : Tableau [indice_min…indice_max] de type_éléments_tableau ;

2) Parcourir un tableau pour effectuer la lecture et l’affichage

Algorithme de recherche du maximum

On supposera que le tableau contient n éléments au préalable.
L’algorithme est le suivant :

Algorithme Recherche_Max
Var T: tab[1..n]: entier;
max, i: entier;
Début
max ← T[1];
Pour i de 2 à n Faire
Si (T[i] > max) Alors
max ← T[i];
FinSi
FinPour
Ecrire("Le max est: ", max);
Fin
Exercice 2
Algorithme Ajout
Var
T : tableau [1..100] de réels ;
N : entiers ;
X : réel ;
Début
Ecrire(‘‘entrer la valeur de l’’élément à ajouter :’’)
;
Lire(X) ;
N<-- N+1 ; //il y aura un élément en plus
T[N] <-- X ;
Finsi
Fin

Exercice 3
Algorithme tableau_Notes
Var
N : tableau [1..30] de réels ;
i :entier;
Début
//saisit des valeurs par l'utilisateur
Pour i <-- 1 à 30 faire
Ecrire(‘entrer la note N° ’,i);
Lire(N[i]) ;
Fin pour fin

Exercice 4
Algorithme tableau_somme
Var
V : tableau [1..5] de réels ;
S : réel ;
i :entier;
Début
//lecture des éléments du tableau
Pour i <-- 1 à 5 faire
Ecrire(‘‘entrer l’élément N° ‘’,i);
Lire(V[i]) ;
Fin pour
//calcul de la somme des éléments du tableau
S <-- 0 ;
Pour i <-- 1 à 5 faire
S <-- S + V[i] ;
Fin pour
//afficher des éléments du tableau
Pour i <-- 1 à 5 faire
Ecrire(‘’l’’élément N° ‘’,i, ‘’est : ‘‘,V[i]);
Fin pour
Ecrire(‘la somme des éléments du tableau est
:‘,S) ;
fin

Exercice 5
Algorithme saisie_affichage
Var
T : tableau [1..100] de réels ;
N,i : réel ;
Début
Ecrire(‘entrer le nombre d’éléments du tableau :’) ;
Lire(N) ;
// lecture des éléments du tableau
Pour i <-- 1 à N faire
Ecrire(‘entrer l’élément N° ’,i);
Lire(T[i]) ;
Fin pour
//afficher des éléments du tableau
Pour i <-- 1 à N faire
Ecrire(‘l’’élément T[’,i,’] est : ‘,T[i]);
Fin pour
Fin