Algorithmique II [SMI S3] USMBA

Pr.Noureddine En- Nahnahi

FSDM
FES

Chapitre 2. Tableaux et types structurés

http://j.gs/18042175/smi-s3-2017-2018
TABLEAUX STATIQUES

TABLEAUX
Un tableau est utilisé pour représenter une suite d’éléments de même type
( T = (t1,t2,…,tn)).
Déclaration d’un tableau (à un dimension):
<nom du tableau> : tableau [1 .. max] de <type des éléments>
(exemple T : tableau [1..20] de réel)
où : - max est une constante entière (positive)
- le type des éléments est quelconque (de base ou déclaré).

• La taille (ou longueur) d’un tableau est le nombre d’éléments du tableau;

elle est toujours inférieure ou égale à max.

• les tableaux, en algorithmique, commencent à l’indice 1(en C et en java,

ils commencent à l’indice 0)

20
TABLEAUX STATIQUES

Opérations (de base) sur les tableaux:

Accès à un élément du tableau :
<nom du tableau> [<indice>]
(indice est une expression de type entier)
Parcours : (on utilise un indice et une boucle pour ou tant que)
(exemple :
pour i=1 à n faire //n est le nombre d’éléments du tableau T
traiter( T[i]) // traiter() est une fonction ou algorithme à définir
fpour;
Recherche d’un élément dans un tableau
Insertion d’un élément
Suppression d’un élément

21
TABLEAUX STATIQUES

o Exemple : recherche de la position d’un élément dans un tableau de réels.

fonction localiser(T: tableau[1..max]de réel, n : entier, val :réel) : entier

i : entier;
trouve : booléen;
début
i := 1; trouve := faux;
tantque (i ≤ n) et (non trouve) faire
si (T[i] = val) alors
trouve := vrai;
sinon i := i + 1;
fsi;
ftantque;
si (trouve) alors retourner(i)
sinon retourner(0);
fsi
fin

22
TABLEAUX STATIQUES

insertion d’élément x dans un tableau T à n éléments à la position p.

Fonction inserer(T : tableau[1..max] de réel, ref n : entier, x : réel, p : entier) : vide
// 1 ≤p ≤ n
i : entier;
début
i := n;
tantque i ≥ p faire
T[i+1] := T[i];
i := i – 1;
ftantque
T[p] := x;
n := n + 1;
fin

23
TABLEAUX STATIQUES

Suppression d’une valeur d’un tableau T, qui se trouve à la position

p.
Fonction supprimer(T : tableau[1.. max] de réel, ref n : entier, p : entier) : vide
i : entier;
début
i := p;
tantque i < n faire
T[i] := T[i+1];
i := i + 1;
ftantque;
n := n – 1;
fin

24
TABLEAUX STATIQUES

o Remarques :
Le nom du tableau, dans une liste de paramètres
formels, est une référence.
(en C, l’adresse de T[i], notée T + i, est calculée:
adresse(T[i]) = adresse(T[0]) + sizeof(<type des éléments>) * i)

L’insertion (resp. suppression) d’un élément à un

indice i, nécessite un décalage des (n- i +1)
derniers éléments d’une position à droite (resp. à
gauche)

25
STRUCTURE (ENREGISTREMENT)

Structures (ou enregistrements)

Le type structure est utilisé pour représenter une suite d’éléments pas
nécessairement de même type, chaque élément est appelé champs.
Déclaration d’un type structure:
<nom de type structure> = structure
<variable_champs1> : <type_champs1>;
<variable_champs2> : <type_champs2>;
.
.
fstructure

Déclaration d’une variable de type structure:

<variable_structure> : <nom de type structure>

26
STRUCTURE (ENREGISTREMENT)

Par analogie au type struct de C:

Déclaration :
struct <nom de la structure> {
<type_champs1> <variable_champs1>
<type_champs2> <variable_champs2>
.
.
}
Déclaration d’une variable de type structure:
struct <nom de la structure> <variable>

• Ou avec la définition de type : typedef

typedef struct <nom de la structure> <type_structure>;
Déclaration d’une variable :
<type_structure> <variable>

27
STRUCTURE (ENREGISTREMENT)

Exemples :
Adresse = structure
numero_rue : entier;
nom_rue : tableau[1..20] de caractère;
code_postal : entier;
fstructure

Point = structure
abscisse : réel;
ordonnee : réel;
fstructure

Déclaration des variables:

adr : Adresse;
p : Point

28
STRUCTURE (ENREGISTREMENT)

Opération sur les structures :

Accès à un champs :
<variable de type structure>. <variable_champs>
(ex: p.abcisse désigne l’abscisse du poin p)
Affectation :
<variable_type_structure> := <variable_type_structure>
(L’affectation se fait champs par champs)

Exemple : manipulation des complexes

29
STRUCTURE (ENREGISTREMENT)

Déclaration de type complexe:

Complexe = structure
p_reel, p_imag : réel;
fstructure

fonction plus(z1 : Complexe, z2 : Complexe) : Complexe

z : Complexe;
debut
z.p_reel := z1.p_reel + z2.p_reel;
z.p_imag := z1.p_imag + z2.p_imag;
retourner(z);
fin

30
 Type structurés et enregistrements

ANNEXE : Manipulation d'un enregistrement

La manipulation d'un enregistrement se fait au travers de ses champs. Comme pour les tableaux,
il n'est pas possible de manipuler un enregistrement globalement, sauf pour affecter un enregistrement
à un autre de même type (ou le passer en paramètre). Par exemple, pour afficher un enregistrement il
faut afficher tous ses champs un par un.

A. Accès aux champs d'un enregistrement

Alors que les éléments d'un tableau sont par l’intermédiaire de leur indice, les champs d'un
enregistrement sont accessibles à travers leur nom, grâce à l'opérateur '.'

nom_enregistrement . nom_champ
représente la valeur mémorisée dans le champ de l'enregistrement

Par exemple, pour accéder à l'âge de la variable pers2, on utilise l'expression:

pers2.âge
Remarque : la lecture d'une telle expression se fait de droit à gauche : l'âge de la personne2.

? Attention : le nom d'un champ est TOUJOURS précédé du nom de l'enregistrement auquel il
appartient. On ne peut pas trouver un nom de champ tout seul, sans indication de l'enregistrement.

Les champs d'un enregistrement, tout comme les éléments d'un tableau, sont des variables à qui on
peut faire subir les mêmes opérations (affectation, saisie, affichage,… ).

Exemple 1:
Programme de saisie des données concernant les personnes pers1 et pers2, puis affichage de la
différence d'âge entre ces deux personnes

Programme Exemple
Type
Structure tpersonne
nom : chaîne
prénom : chaîne
âge : entier
FinStruct

Var
pers1, pers2 : tpersonne

Début
Aff "Entrez le nom puis l'age de la personne 1"
Saisir pers1.nom, pers1.age // il est impossible d'écrire Saisir pers1
Aff "Entrez le nom puis l'âge de la personne 2"
Saisir pers2.nom, pers2.age
Aff "La différence d'âge entre ", pers1.nom, " et ", pers2.nom, " est de "
Si pers1.age > pers2.age
Alors Aff pers1.age – pers2.age, " ans "
Sinon Aff pers2.age – pers1.age, " ans "
FinSi
Fin

Rappel : il est possible d'affecter un enregistrement à un autre de même type. Là, il serait correct
d'écrire
pers1 <- pers2

32
 Type structurés et enregistrements

B. un enregistrement comme champ d'une structure

Supposons que dans le type personne, nous ne voulions plus l'âge de la personne, mais sa date de
naissance. Une date est composée de trois variables (jour, mois, année) indissociables 1. Une date
correspond donc à une entité du monde réel qu'on doit représenter par un type enregistrement à 3
champs.
Si on déclare le type date au préalable, on peut l'utiliser dans la déclaration du type personne pour le
type de la date de naissance.

Un type structuré peut être utilisé comme type pour des champs d'un autre type structuré

TYPE
Structure date
jour: entier
mois: chaîne
année: entier
FinStuct

Structure personne
nom: chaîne
ddn: date
FinStruct

Pour accéder à l'année de naissance d'une personne, il faut utiliser deux fois l'opérateur '.'
pers1.ddn.année

Il faut lire une telle variable de droite à gauche : l'année de la date de naissance de la personne 1.

Exemple Complet
Un produit est livré par un seul fournisseur. Un fournisseur est caractérisé par son code, sa raison sociale
et son numéro de téléphone.

Structure fournisseur
code_frs : chaine
raison_sociale: chaine
tel: chaine
FinStruct

Structure Produit
code: chaîne
lib: chaîne
paht: réel
pvht: réel
txtva: réel
frs: fournisseur
FinStruct

Var
p: produit

Voilà l'instruction qui permet d'afficher le numéro de téléphone du fournisseur du produit p.frs.tel

Aff "téléphone du fournisseur de ", p.lib, " : ", p.frs.tel

1 En supposant que le type Date n'existe pas.

33
 Type structurés et enregistrements

C. Un tableau comme champ de structure

Il est possible aussi qu'un champ de type structuré soit de type tableau, voire tableau structuré !
Exemple d'un type structuré contenant un tableau simple
Imaginons une structure mémorisant des critères géographiques de villes (altitude, type de climat, … ).
Certains de ces critères pourraient pertinemment être mémorisés pour chaque mois de l'année (par
exemple température moyenne, précipitations moyennes, … )

Structure Ville
Nom : chaîne
Alt : entier //Altitude moyenne
Climat : Chaîne //type de climat
Temp : tableau[1..12] de réel //température moyenne par mois
Précip : tableau[1..12] de réel //précipitations moyennes par mois
FinStruct

Ensuite, on peut évidemment déclarer une ville :

MaVille : Ville

Voilà comment on pourrait initialiser cette ville

Afficher "Nom de la ville?"

Saisir MaVille.Nom
//idem pour l'altitude et le climat
Afficher "Veuillez entrer successivement les températures moyennes sur les 12 mois"
//on utilise une boucle pour remplir le tableau des températures
Pour i de 1 jusqu'à 12 Faire
Aff "mois ", i
Saisir MaVille.Temp[i]
FinPour
//idem pour les précipitations

Si on voulait afficher par exemple la température moyenne au mois de juillet de MaVille, on écrirait
tout simplement :

Aff MaVille.Temp[7] // vu que le tableau commence à 1, 7 est l'indice de juillet

III. Les tableaux d'enregistrements (ou tables)

Il arrive souvent que l’on veuille traiter non pas un seul enregistrement mais plusieurs. Par exemple,
on veut pouvoir traiter un groupe de personne. On ne va donc pas créer autant de variables du type
personne qu’il y a de personnes. On va créer un tableau regroupant toutes les personnes du groupe. Il
s’agit alors d’un tableau d’enregistrements, autrement appelé « table ». Une table en algorithmique a
beaucoup de points communs avec une table d’une base de donnée. Les colonnes sont appelées
champs et les lignes enregistrements.

34
 Type structurés et enregistrements

Exemple page suivante

Const
NP = 20 // nombre de personnes du groupe

Type
Structure personne
nom: chaîne
age: entier
FinStruct

Var
groupe: tableau[1..NP] de personnes

Chaque élément du tableau est un enregistrement, contenant plusieurs variables de type différent. On
accède à un enregistrement par son indice dans le tableau.
groupe[2] représente la deuxième personne du groupe
groupe[2].nom représente le nom de la deuxième personne du groupe
nom âge nom des champs
1

3 enregistrements
4

indices du tableau

? Attention!
groupe.nom[3] n'est pas valide.
Pour accéder au nom de la troisième personne du tableau, il faut écrire groupe[3].nom

Une table comme champ de structure

Les tableaux d'enregistrements peuvent aussi être eux même servir de type dans un autre type structuré

Exemple
Contexte : Dans un comité d'entreprise, on veut pouvoir connaître les enfants des employés et leur date
de naissance (pour le petit cadeau!). On suppose que le nombre d'enfant maxi d'un employé est de 10.

Structure Enfant
Nom : chaîne
Prénom : chaîne
Journaiss : entier
Moisnaiss : entier
Anneenaiss :entier
FinStructure

Structure Employé
Nom : chaîne
Prénom : Chaîne
…
Nbenf : entier //nombre d'enfants
Progéniture : tableau[1..10] d'Enfant
FinStruct
35
Et évidemment, on pourrait déclarer un tableau d'Employé. Ce qui ferait des tableaux imbriqués les
uns dans les autres…

Var
TabEmp : tableau[1..MAX] d'Employé

Pour afficher par exemple les anniversaires de tous les enfants de l'employé d'indice i, il faudrait
parcourir le tableau de ses enfants (avec un autre indice que i).

Si TabEmp[i].NbEnf ? 0 //on vérifie d'abord que l'employé a des enfants

Alors
Pour j de 1 jusqu'à TabEmp[i].NbEnf Faire
Aff TabEmp[i].Progéniture[j].Prénom
Aff "anniversaire le ", TabEmp[i].Progéniture[j].journaiss, TabEmp[i].Progéniture[j].moisnaiss
FinPour
Sinon Aff "l'employé ", TabEmp[i].Nom, " n'a pas d'enfant"
FinSi

IV Les enregistrements comme paramètres

Comme c'est le cas avec les tableaux, il est possible de passer un enregistrement en
paramètre d'une fonction ou d'une procédure (on n'est pas obligé de passer tous les champs
uns à uns, ce qui permet de diminuer le nombre de paramètres à passer). On peut aussi
avoir un enregistrement comme valeur de retour d'une fonction

Exemple

Struct hms
heure : entier
minute : entier
seconde : entier
FinStruct

Remarque : Les types structures sont déclarées en global

Fonction nbsec(time : hms) : entier

Var nbsec : entier
Début
nbsec <- time.heure* 3600 + time.minute * 60 + time.seconde
Retourne nbsec
FinProcédure

Procédure converthms( nbs :entier

REF time : hms)
Début
time.heure <- nbs DIV 3600
reste <- nbs MOD 3600
time.minute <- reste DIV 60
time.seconde <- nbs MOD 60
FinProcédure

Du coup, la procédure converthms n'a plus qu'un seul paramètre résultat et peut être transformée en
fonction

36
 Type structurés et enregistrements

Fonction converthms(nbs :entier) : hms

Var
time : hms
Début
time.heure <- nbs DIV 3600
reste <- nbs MOD 3600
time.minute <- reste DIV 60
time.seconde <- nbs MOD 60
retourne time
FinProcédure

Exemples d'appels

Appel de la fonction converthms :

Var duréesec : entier

durée : hms
Début
Saisir duréesec
durée <- converthms(duréesec)
Aff "durée correspondante: ", durée.heure, "h ", durée.minute, "m ", durée.seconde, "s"
Fin

Appel de la fonction nbsec dans une autre fonction durée :

Fonction durée (h1 : hms, h2: hms) : hms

Var
d : hms
sec : entier
Début
sec <- nbsec(h2) – nbsec(h1)
d <- converthms(sec) retourne converthms(nbsec(h2) – nbsec(h1))
retourne d
FinFonction

Remarque :
Lors de l'appel d'un sous-programme, un paramètre peut-être représenté par un ou plusieurs champ
d'un enregistrement (tout comme on peut passer la valeur d'une seule case d'un tableau en paramètre)

37