Programmation Et Structures de Données

UNIVERSITE DES SCIENCES ET DE LA TECHNOLOGIE HOUARI BOUMEDIENNE
Programmation et
structures de données
Licence MI 3, semestre 2
Mohamed HAMDAH
Section 9
2015/2016
Sommaire
Chapitre I : les enregistrements
1. Introduction ....................................................................................................................... 1
2. Définittion ......................................................................................................................... 1
3. Déclaration d'un enregistrement ....................................................................................... 2
4. Les opérations sur les enregistrements ............................................................................. 3
4.1. Référence d'un champ .................................................................................................. 3
4.2. Initialisation d’un champ.............................................................................................. 4
4.3. Affichage d’un champ .................................................................................................. 4
5. Emboîtement (imbrication) d’enregistrements ................................................................. 5
6. L’instruction ’’avec’’ ........................................................................................................ 7
7. Exercices d’application ................................................................................................... 10
Chapitre II : les pointeurs
1. Introduction ..................................................................................................................... 15
2. Définition ........................................................................................................................ 15
3. Déclaration d’un pointeur ............................................................................................... 15
4. Les opérations de manipulation de pointeurs.................................................................. 16
4.1. Création d’une variable dynamique ........................................................................... 16
4.2. Initialisation d’une variable pointeur ......................................................................... 17
4.3. Initialisation d’une variable dynamique (pointée) ..................................................... 17
4.4. Suppression d’une variable dynamique ..................................................................... 18
5. Exemples ......................................................................................................................... 18
Chapitre III : les listes linéaires chaînées
1. Introduction ..................................................................................................................... 21
2. Définition ........................................................................................................................ 21
3. Déclaration d’une liste .................................................................................................... 21
4. Création d’une liste chaînée ............................................................................................ 23
4.1. Création d’une liste LIFO .......................................................................................... 23
4.2. Création d’une liste FIFO........................................................................................... 25
5. Les traitementse effectués sur les listes chaînées ........................................................... 28
5.1. L’affichage du contenu d'une liste ............................................................................. 28
5.2. La recherche d’un élément ......................................................................................... 28
5.2.1. La recherche suivant la valeur de l'élément ............................................................... 28
5.2.2. Recherche suivant la position de l'élément ................................................................ 29
5.3. Insertion d’un élément................................................................................................ 30
5.3.1. Insertion au début ....................................................................................................... 30
5.3.2. Insertion à la fin ......................................................................................................... 31
5.3.3. Insertion au milieu...................................................................................................... 31
5.4. Suppression d’un élément .......................................................................................... 32
5.4.1. Suppression au début.................................................................................................. 32
5.4.2. Suppression à la fin .................................................................................................... 33
5.4.3. Suppression au milieu ................................................................................................ 33
6. Listes circulaires ............................................................................................................. 34
6.1. Définition ................................................................................................................... 34
6.2. Création d'une liste circulaire ..................................................................................... 34
6.3. L'affichage du contenu d'une liste circulaire .............................................................. 35
6.4. Recherche d'un élément dans une liste circulaire ....................................................... 35
6.4.1. Recherche en connaissant la valeur de l'élément ....................................................... 35
6.4.2. Recherche en connaissant la position de l'élément .................................................... 36
7. Listes bidirectionnelles ................................................................................................... 36
7.1. Définition ................................................................................................................... 36
7.2. Création d'une liste bidirectionnelle ........................................................................... 37
8. Exemples d'application ................................................................................................... 37
Chapitre IV : les fichiers séquentiels
1. Introduction ..................................................................................................................... 40
2. Définition ........................................................................................................................ 40
3. Les caractéristiques d’un fichier à accès séquentiel ....................................................... 40
4. Déclaration d’un fichier .................................................................................................. 41
5. Les primitives de manipulation de fichiers ..................................................................... 42
5.1. L’assignation .............................................................................................................. 42
5.2. L’ouverture d’un fichier ............................................................................................. 43
5.2.1. L’ouverture en mode écriture (Création) ................................................................... 43
5.2.2. L’ouverture en mode lecture ...................................................................................... 43
5.3. La fermeture d’un fichier ........................................................................................... 44
5.4. Les opérations d’entrée/sortie sur un fichier .............................................................. 44
5.4.1. L’opération d’entrée ................................................................................................... 44
5.4.2. L’opération de sortie .................................................................................................. 45
5.5. Marque de fin de fichier ............................................................................................. 45
6. Exemples d’application................................................................................................... 46
Chapitre I : Les enregistrements

1. Introduction
Les tableaux sont utilisés pour regrouper plusieurs variables de même type. Si par contre
les variables sont de types différents, comment faire alors pour les mettre dans une même
structure de données?
Comme solution à ce problème nous utilisons la structure de donnée statique
enregistrement.
2. Définittion
Un enregistrement est une structure de données statique composée d’un ensemble fini
d’éléments appelés champs. Chaque champ est décrit par un nom et un type. Le type d'un
champ peut être soit, un type scalaire (entier, réel, booléen ou car) ou bien un type
structuré (tableau, chaîne, voire un enregistrement). Les champs d’un enregistrement ne
sont pas forcément de même type.
Exemple :
Proposer une structure de données pour sauvegarder les renseignements d'un enseignant;
sachant qu'un enseignant est décrit par quatre champs :
1. Numéro de sécurité sociale NSS de type entier,
2. Nom et prénom de type chaîne de caractères, et
3. Date de naissance de type tableau de trois entiers.
Comme solution on utilise une struture de données de type enregistrement composé de

quatre champs :
NSS Enseignant
Nom NSS
Nom
Prénom
Prénom
Date_naissance
JJ MM AAAA
USTHB, LIC_MI, programmation et structures de données, 2015/2016 Page : 1

3. Déclaration d'un enregistrement

La déclaration d'une variable de type enregistrement se fait dans la partie variable par la
déclaration des différents champs qui le composent conformément à la syntaxe suivante :
Syntaxe :
Var
<idf_enregistrement> : Enregistrement
<idf_champ_1> : <type_champ_1> ;
<idf_champ_2> : <type_champ_2> ;
…
<idf_champ_N> : <type_champ_N> ;
Fin;
Exemple :
La déclaration d’une variable de type enregistrement décrivant un enseignant est donnée
comme suite :
Var
Enseignant : Enregistrement
NSS : entier;
Nom : chaîne;
Prénom : chaîne;
Date_naissance : tableau [1..3] de entier;
Fin;
Remarque
Un type enregistrement peut être déclaré dans la partie déclarations de types.
Syntaxe :
Type
<idf_type_enregistrement> = Enregistrement
<idf_champ_1> : <type_champ_1>;
<idf_champ_2> : <type_champ_2>;
…

<idf_champ_N> : <type_champ_N>;
Fin;
Var
<idf_enregistrement> : <idf_type_enregistrement>;
Exemple :
Type
Type_enseignant = Enregistrement
NSS : entier;
Nom, Prénom : chaine;
Date_naissance : tableau [1..3] de entier;
Fin;
Var
Enseignant : Type_enseignant;
4. Les opérations sur les enregistrements

On distingue plusieurs types d'opérations à savoir : la lecture, l'écriture…
4.1. Référence d'un champ

Un champ est référencé par son nom précédé du nom de la variable enregistrement dans la
quelle est déclaré comme suite.
Syntaxe :
<identificateur_enregistrement>.<identificateur_champ>
Exemple :
Enseignant.NSS est la référence du champ NSS déclaré dans l’enregistrement enseignant.
Remarque :
La variable enregistrement <identificateur_enregistrement> peut être elle même un champ
d'un autre enregistrement, et par conséquent la référence d'un champ peut être généralisé
comme suite :

Syntaxe :
<chemin_champ>.<identificateur_champ>
<chemin> est le chemin d'accès au champ <identificateur_champ>. Il est composé d'une

suite de variables (champs) de type enregistrement séparés par des points :
<champ1>.<champ2>.<champ3>.<identificateur_champ>
4.2. Initialisation d’un champ

L’initialisation d’un champ dépend de la nature de son type. S’il est de type scalaire donc
elle peut se faire soit par une affectation ou bien par une lecture (lire). Si le type par
contre est structuré, nous descendons dans la hiérarchie jusqu'à l’obtention des variables
de type scalaire (simple).
Syntaxe :
<idf_enregistrement>.<idf_champ_scalaire>←<expression>;
ou
Lire (<idf_enregistrement>.<idf_champ_scalaire>);
Exemple :
Pour initialiser la variable enseignant déclaré précédemment, nous utilisons les instructions
suivantes :
Enseignant. NSS ← 27785916087;

Enseignant. Nom ← "HAMDAH";
Enseignant. Prénom ← "Mohamed";
Enseignant. date_naissance[1] ← 15;/*jour de naissance*/
Enseignant. date_naissance[2] ← 12;/*mois de naissance*/
Enseignant. date_naissance[3] ← 1974;/*année de naissance*/
ou
Lire (Enseignant. NSS, Enseignant. Nom, Enseignant. Prénom, Enseignant.
date_naissance[1], Enseignant. date_naissance[2], Enseignant. date_naissance[3] );
4.3. Affichage d’un champ

L’affichage d’un champ de type scalaire se fait par la primitive écrire. Par contre si le
champ est structuré, son affichage se réalise à la base de l’affichage des variables simples

qui le composent.
Syntaxe :
Ecrire (<idf_enregistrement>.<idf_champ>)
Exemple :
écrire (Enseignant. NSS, Enseignant. Nom, Enseignant. Prénom, Enseignant.

date_naissance[1], Enseignant. date_naissance[2], Enseignant. date_naissance[3] );
5. Emboîtement (imbrication) d’enregistrements

Pour l’exemple précédent nous avons déclaré la date de naissance comme étant un vecteur
de trois éléments. En effet, on peut déclarer la date comme un enregistrement composé de
trois champs : jour, mois et année comme suit :
Type
Date = Enregistrement
Jour : 01..31;
Mois : 01..12;
Année : 1974..2030;
Fin;
NSS : entier;
Nom, Prénom : chaîne;
Date_naissance, Date_recrutement: Date;
Fin;
Var
Enseignant : type_enseignant;
Après la déclaration de la variable enseignant nous obtenons l’état de mémoire suivant:
Enseignant
?
?
?
? ? ?
? ? ?

Cette déclaration peut être représentée par un arbre comme nous montre le schéma
suivant :
Enseignant
NSS Nom Prénom D_naissance D_recrutement
Jour mois année Jour mois année
On dit en ce moment que l'enregistrement enseignant engendre directement les deux en

registrements date_recrutement et date_naissance.
Pour l’initialisation de la nouvalle variable enseignant nous suivons les intructions
suivantes :
Enseignant.NSS ← 27785916087;
Enseignant.nom ← "HAMDAH" ;
Enseignant.prénom ← "Mohamed" ;
Enseignant.date_naissance.jour ←15 ;
Enseignant.date_naissance.mois ←12 ;
Enseignant.date_naissance.année ←1974 ;
Enseignant.date_recrutement.jour ←01 ;
Enseignant.date_recrutement.mois ←12 ;
Enseignant.date_recrutement.année ←2003 ;
Après le déroulement de cet algorithme nous obtiendrons l’état de mémoire suivant :
Enseignant
27785916087
HAMDAH
Mohamed
15 12 1974
01 12 2003
Remarque
Le champ jour déclaré dans l’enregistrement date_naissance et celui déclaré dans
l’enregistrement date_recrutement sont appelés homonymes.

6. L’instruction ’’avec’’
Pour simplifier l’écriture de l’algorithme et de ne pas réécrire à chaque fois la référence
enseignant.date_naissance ou enseignant.date_recrutement, nous utilisons l'instruction
"avec".
Syntaxe :
Avec <variable_enregistrement>
Faire
<liste d’actions> ;
Fait;
<variable_enregistrement> désigne le nom d’une variable enregistrement ou son chemin
d’accès.
<liste d’actions> contient la liste d’actions qui manipulent directement à un champ sans
mentionner son chemin d’accès.
Exemple :
L’initialisation de l’enregistrement enseignant peut se faire comme suit :
Avec Enseignant
Faire
NSS ← 27785916087 ;
nom ← "HAMDAH" ;
prénom ← "Mohamed" ;
date_naissance.jour ←15 ;
date_naissance.mois ←12 ;
date_naissance.année ←1974 ;
date_recrutement.jour ←01 ;
date_recrutement.mois ←12 ;
date_recrutement.année ←2003;
Fait;
Pour initialiser directement l’enregistrement date_naissance se trouvant dans
l’enregistrement enseignant nous utilisons les instructions suivantes :
Avec Enseignant.date_naissance
Faire
jour ←15 ;
mois ←12 ;
année ←1974 ;
Fait;

il existe une autre forme de l'intruction avec, il s'agit de la forme imbriquée comme suite :
Avec Enseignant
Faire
NSS ← 27785916087 ;
nom ← "HAMDAH" ;
Avec date_naissance
Faire
jour ←15 ;
mois ←12 ;
année ←1974 ;
Fait;
Avec date_recrutement
Faire
jour ←01 ;
mois ←12 ;
année ←2003;
Fait;
Fait;
Remarque
Dans le cas où nous n’avons pas de variables homonymes, nous pouvons utiliser une autre
syntaxe de l’instruction avec.
Syntaxe
Avec <liste_variables_enregistrement>
Faire
<liste_actions>;
Fait;
<liste_variables_enregistrement> représente une liste de variables enregistrement «V, V1,V2
..,Vn» . L’enregistrement V représente la racine, alors que les Vi représentent les
variables enregistrement engendrées directement ou indirectement par V.
Exemple :
Avec Enseignant, date_naissance

Faire
NSS ← 27785916087 ;

nom ← "HAMDAH" ;
jour ←15 ;
mois ←12 ;
année ←1974 ;
Fait;
Avec enseignant, date_recrutement
Faire
jour ←01;
mois ←12;
année ←2003;
Fait;
Exemple :
Soit l’instruction avec suivante :
Avec Enseignant, date_naissance, date_recrutement

Faire
Écrire (jour, mois, année) ;
Fait;
Cette écriture est fausse (ambiguë), car les champs : jour, mois et année sont déclarés dans
les deux enregistrements date_naissance et date_recrutement. En effet, pour afficher ceux
déclarés dans la date de naissance, nous devrons le spécifier soit en donnant le chemin
juste après le mot clés avec ou bien en utilisant une autre instruction avec.
Avec Enseignant
Faire
Avec
Faire
date_naissance
Écrire (jour, mois,année);
Fait;
Fait;
Ou bien
Avec Enseignant.date_naissance
Faire

Écrire (jour, mois, année);

Fait;
Remarque :
La première forme est plus générale et offre plus de souplesse.
7. Exercices d’application
Exercice 1
Ecrire une fonction qui vérifie la cohérence des dates de naissance et de recrutement lues.
Exercice 2
Ecrire un algorithme qui affiche l’age d’un enseignant exprimé en nombre de jours.
Exercice 3
Ecrire un algorithme sous forme d’actions paramétrées permettant la lecture et la
sauvegarde des renseignements de 20 enseignants.
Exercice 4
Ecrire une procédure affichage qui affiche la liste du tous les enseignants suivant l’ordre
alphabétique.
Solution :
Date_recrutement = date_naissance + age_minimum_enseignant.
Const
Age_min =25;
Type
T_jours = 1..31;
T_mois = 1..12;
T_année = 1974..2010;
Jour : T_jours;
Mois : T_mois;
Année : T_année;
Fin;
Fonction vérification (date_recrutement, date_naissance : date) : booléen;
Début
Si (date_rerutement.année <= date_naissance.année+age_min)
alors vérification ←faux;

Sinon vérification ←vrai

Fsi;
Fin;
Si on veut comparer deux dates date1 et date2 de type date alors on utilise la procédure
comparaison.
Type
Résultat = (égale, supérieure, inférieure); {déclarations d'une énumération}
Procédure comparaison (e/date1, date2 : date ; s/rep : résultat) ;
Début
Si (date1.année < date2.année)
alors rep ←inférieure;
Sinon si (date1.année >date2.année)
alors rep←supérieure;
sinon si (date1.mois<date2.mois)
alors rep ← inférieure;
sinon si (date1.mois >date2.mois)
alors rep←supérieure;
sinon si (date1.jour<date2.jour)
alors rep ←inférieure;
Sinon si (date1.jour>date2.jour)
alors rep ←supérieure;
Sinon rep ←égale;
Fsi;
Fsi
Fsi;
Fsi
Fsi;
Fsi;
Fin;
Solution :
Algorithme exemple;
Const
Age_min = 25;
Type
T_jour = 1..31;
T_mois = 1..12;
T_année = 1974..2010;

Jour : T_jours;
Mois : T_mois;
Année : T_année;
Fin;
NSS : entier;
Nom, Prénom : chaine[30];
Date_naissance, Date_recrutement : Date;
Fin;
Var
Enseignant : type_enseignant ;
V_enseignant : tableau [1..20] de type_enseignant ;
Début
Pour i ← 1 à 20
Faire
Avec V_Enseignant[i]
Faire
Lire (NSS) ;
Lire(nom, prénom) ;
avec date_naissance
Faire
Lire (jour, mois, année) ;
Fait;
Avec date_recrutement
Faire
Lire (jour,mois,année);
Fait;
Fait;
Fin.

Chapitre II : Les pointeurs

1. Introduction
une variable de type statique (entier, réel, car, chaîne, tableau, enregistrement) en mémoire
est référencée par son identficateur et occupe le même espace jusqu'à la terminaison de
l'algorithme malgré elle est utilisée uniquement dans un partie de l'algorithme.
Y a-t-il un moyen pour récupérer l'espace alloué à cette variable pour le donner à une autre ?
Comme solution, on utilise un autre de type données appelé pointeur (adresse) qui nous
permet de référencer une variable via son adresse.
2. Définition
Une variable de type pointeur est une variable qui peut stocker une valeur de type adresse.
Le type pointeur est urilisé pour gérer une variable pointée appelée variable dynamique. Elle
n’est pas explicitement déclarée dans la partie déclaration, mais elle est crée et libérée,
dynamiquement, selon le besoin dans la partie actions d’un algorithme.
3. Déclaration d’un pointeur

Syntaxe :
Var
<idf_pointeur> : ^ <type_variable_pointée>;
<type_variable_pointée> représente le type de la variable dynamique pointée par le pointeur

<idf_pointeur>. Le type d’une variable dynamique peut être soit, un type simple ou structuré.
Une variable de type pointeur peut prendre toutes les valeurs d’adresses valides d’une
machine (mémoire).
Exemple :
Ptr_entier : êntier;
Suite à cette déclaration nous obtiendrons l’état suivant :
Ptr_entier
?
Remarque :
Si le type de la variable pointée est structuré, il est préférable de le déclarer d’abord dans la
partie type.
Exemple :
La déclaration d’un pointeur sur un enregistrement contenant les informations d’un
enseignant est donnée comme suite :

Type
Enseignant = Enregistrement
NSS : entier;
Date_naissance : date;
Fin;
Var
ptr_enseignant : ^ Enseignant ;
On peut déclarer aussi un type pointeur comme suit :
Type
NSS : entier;
Fin;
Ptr_enseignant = ^ Enseignant ;
Var
P, q : ptr_enseignant ;
4. Les opérations de manipulation de pointeurs

4.1. Création d’une variable dynamique
Une variable dynamique est crée via l'appel de la procédure allouer() qui a comme paramètre
d’entrée-sortie le nom de la variable pointeur.
Syntaxe
Allouer (<Idf_pointeur>);
Exemple :
Allouer (ptr_entier);
Allouer (p);
Après l’exécution de ces deux instructions nous obtiendrons l’état de mémoire suivant:
@0 P @1 @1
Prt_entier @0
Remarque :
Allouer (p,q);
4.2. Initialisation d’une variable pointeur

Une variable pointeur peut être initialisée soit, par une affectation, ou bien lors de la création
de la variable dynamique par l'appel de la procédure allouer.
Exemple :
P ←nil;
q ←p ;
Allouer (P);
Allouer (q);
Remarque :
Les seules opérations autorisées sur une variable de type pointeur sont : l’affectation, la
relation d’égalité ‘=’, et de différence ‘<>’.
Exemple :
P ←nil;
L’expression logique P<>nil retourne la valeur faux.
4.3. Initialisation d’une variable dynamique (pointée)

Une variable dynamique n’est accessible qu’à travers son adresse (son pointeur).
Exemple :
Allouer (P);
P^ ←125;
Allouer (Q);
Q^ ←p^ ;
Écrire (P^);
Remarque :
Une variable de type pointeur ne peut être lue ni affichée. En effet, les instructions suivantes
sont incorrectes.
Écrire (P);
lire (p)

4.4. Suppression d’une variable dynamique

La suppression d’une variable dynamique permet de récupérer son espace mémoire.
Syntaxe
Libérer (<idf_pointeur>)
Exemple
Libérer (P);
Après la libération de l’espace mémoire de la variable dynamique P^ son contenu sera perdu
et son espace mémoire peut être alloué à d'autres variables dynamiques.
5. Exemples
Exemple 1 :
Dérouler l’algorithme suivant :
Algorithme pointeurs;
Type
Ptr_entier=êntier ;
Var
P, Q : Ptr_entier;
Début
Allouer (P);
P^ ←10;
Q ←P;
Q^ ←P^+2;
Q ←Nil;
Libérer (P)
Allouer (Q);
Fin.

P @0 @0 Q ?
?
P @0 @0 Q ?
10
P @0 @0
Q @0
12
P @0 @0 Q Nil
12
P ? Q Nil
P ? @0 Q @0
?
Exemple 2 :
Écrire un algorithme permettant la lecture et la sauvegarde des renseignements de N
enseignants (N<100).
NB : Les éléments du vecteur sont de type pointeur.
Algorithme enseignants;
Type
Ptr_enseignant = ênseignant;
NSS : entier;
Fin;

Vecteur_ens = tableau [1..100] de ptr_enseignant;

Var
T : vecteur_ens;
E : enseignant;
I, n : entier;
Début
Répéter Lire (n) jusqu’à (n>=1) et (n<100);
Pour i ← 1 à n
Faire
Allouer (T[i]);
(*Il faut d’abord initialiser la variable E*)
T^ [i]←E;
Fait;
Fin.

Chapitre III : Les listes linéaires chaînées

1. Introduction
Étant donné un vecteur de N entiers (N<100) :
Vect 10 0 7 2 -80 23
Quoi faire si le nombre d'éléments dépassera 100 ?

L'écriture d'un autre algorithme avec la déclaration d'un autre vecteur plus grand. Ou bien
l'utilisation des variables dynamiques reliées les unes aux autres afin de former une liste de
données appelée : liste linéaire chaînée.
2. Définition
Une liste linéaire chaînée est une suite d’éléments de même type. Chaque élément de la liste
est composé de deux parties : la partie information, et la partie lien de chaînage. La première
partie contient l'information véhiculée par cette liste qui peut être soit de type simple ou
structurée, alors que la seconde (adr_svt) représente un lien de chaînage contenant l’adresse
de l’élément suivant. Les éléments d’une liste ont la même représentation en mémoire comme
nous montre le schéma suivant :
adr 10
info adr_svt
3. Déclaration d’une liste

La déclaration d’une liste se fait par la déclaration de la tête de la liste qui est de type
pointeur conformément à la syntaxe suivante :
Syntaxe
Type
<idf_type_pointeur> = ^ <element_liste>;
<element_liste> = Enregistrement
<info> : <type_info>;
<suivant> : <idf_type_pointeur>;
Fin;

Var
<idf_tête> : <idf_type_pointeur> ;
Exemple
La déclaration d’une liste chaînée contenant des entiers est donnée comme suite :
Ptr =Êlement;
Element=Enregistrement
Info : entier;
Svt : ptr;
Fin;
Var
Liste_entier : Ptr;
Exemple :
La déclaration d’une liste chaînée contenant les informations de N enseignants est donnée
comme suite :
Type
Ptr =Ênseignant;
NSS : entier;
Nom, prénom : chaîne[30];
Date_naissance : Date;
Svt : ptr;
Fin;
Var
Liste_enseignant : ^ enseignant;
Remarque :
Si le type du champ information est structuré, il est préférable de le déclarer d’abord dans la
partie type.
Type
NSS : entier;
Nom, prénom : chaîne[30];
Date_naissance : Date;
Fin;
Ptr_enseignant = Ê_enseignant;
E_enseignant = Enregistrement

Info : enseignant;
Svt : ptr_enseignant;
Fin;
Var
Liste_enseignant : ptr_enseignant;
Exemple
Soit le tableau d’entiers suivant :
Vent 10 0 0 25 0 23
La liste chaînée permettant contenant uniquement les valeurs non nulles de ce vecteur est
donnée comme suite :
Tête 10
10 Nil 25 Nil 23 Nil
Tête 10
4. Création d’une liste chaînée

Nous distinguons deux stratégies de création : LIFO (Last In First Out) et FIFO (First In First
Out) .
4.1. Création d’une liste LIFO

La stratégie LIFO signifie "le dernier rentrant est le premier sortant". Pour ce faire on suit les
étapes suivantes :
1ére étape : Création de la tête de la liste
Tête ← Nil;
2éme étape : Création du premier élément de la liste

Allouer (P);
P^. info ← 23;
P ^.svt ← Nil; ou P ^.svt ← tête;
Tête ←P;
Tête 10 P 10
23 Nil
3éme étape : Création du deuxième élément de la liste
Allouer (P);
P^. info ← 25;
P ^.svt ← tête;
Tête ←P;
Tête 10 P 10
25 Nil 23 Nil
4éme étape : Création du troisième élément de la liste
Allouer (P);
P^. info ← 10;
P ^.svt ← tête;
Tête ←P;
Tête 10 P 10
Généralisation
Pour un vecteur T de N éléments
Tête ←nil;
Pour i ← 1 à N

Faire
Allouer (P);
P^.info ←T[i];
P^.svt ←tête;
Tête ←P;
Fait;
4.2. Création d’une liste FIFO

On peut créer également une autre liste en adoptant une autre stratégie; il s’agit de la
stratégie FIFO (First In first Out) qui signifie "le premier rentrant est le premier sortant".
Pour la création d’une liste chaînée suivant la stratégie FIFO, on suit les étapes suivantes :
1ére étape :Création de la tête de la liste

Tête ← Nil;
Tête Nil
2éme étape :Création du premier élément de la liste

Allouer (P);
P^. info ←10;
Tête ←P;
P^.svt←Nil;
Tête 10 P 10
10 Nil
3éme étape : Création du deuxième élément de la liste

Allouer (Q);
Q^. info← 25;
P^.svt←Q;
P ←Q;
P ^.svt← Nil;
Tête 10
10 Nil 25 Nil

4éme étape : Création du troisième élément de la liste
Allouer (Q);
Q^. info ← 23;
P^.svt ← Q;
P← Q;
P^.svt←Nil
Tête 10
Généralisation
Pour un vecteur de N éléments.
Allouer (P);
P^. info ← T[1];
Tête ←P;
Pour i ← 2 à N
Faire
Allouer (P^.svt);
P←P^.svt;
P^.info ←T[i];
Fait;
P^.svt ←Nil;
ou
Allouer (P);
Tête ←P;
Pour i ← 1 à N-1
Faire
P^. info ← T[i];
Allouer (P^.svt);
P←P^.svt;
Fait;
P^.info ←T[N];
P^.svt ←Nil;

Exemple
Créer une liste linéaire chaînée à partir d’un vecteur de N entiers (N<101).
Algorithme Liste;
Type
Ptr =^élément;
élément = Enregistrement
Info : entier;
Svt : ptr;
Fin;
TAB = tableau [100] de entier;
Var
Téte, p : ptr;
F : TAB;
Procédure liste_lifo ( E/T : tab; E/n : entier ; S/tête : Ptr);

Début
Tête ←Nil;
pour i←1 à N
Faire
Allouer (p);
P^.info←T[i] ;
P^.svt ←tête ;
Tête ←P;
Fait;
Fin;
Procédure liste_fifo (E/T : tab; E/ N : Entier ; S/tête : Ptr);
Début
Allouer (tête); P ←tête;
Pour i ← 1 à N-1
Faire
P^. info ← T[i];
Allouer (P^.svt);
P←P^.svt;
Fait;
P^.info ←T[N];
P^.svt ←Nil;
Fin;

5. Les traitementse effectués sur les listes chaînées

5.1. L’affichage du contenu d'une liste
L'affichage du contenu d'une liste se fait par le parcourt de tous les éléments allant du premier
élément.
Exemple :
La procédure suivante permet d'afficher tous les éléments de la liste :
Procédure affichage (E/tête :Ptr);

Début
Tant que (tête <> Nil)
Faire
Écrire (tête^. info);
Tête← tête^.svt;
Fait;
Fin;
5.2. La recherche d’un élément

La recherche consiste à parcourir tous les éléments de la liste à partir du premier élément
jusqu’au dernier. La recherche s’arrête dés qu’on trouvera l’élément recherché ou bien on
terminera le parcours de tous les éléments.
Nous distinguons deux types de recherche : recherche selon la valeur de l’élément et
recherche suivant la position.
5.2.1. La recherche suivant la valeur de l'élément

Cette recherche retoutne l'adresse de l'élément ou sa position.
Exemple :
Étant donnée la liste suivante:
Tête 10
Cas 1 :
La recherche de l’élément 25 retourne son adresse.

Cas 2 :
La recherche de l’élément 40 retourne la valeur Nil (car il n’existe pas dans la liste).
Fonction adresse (tête : ptr; val : entier) : ptr;
Var
P : ptr;
Début
P ←Nil;
Tant que (tête <> Nil) et (P =Nil)
Faire
Si tête^. Info= val alors P ←tête
Sinon Tête← tête^.svt
Fsi;
Fait;
Adresse←P;
Fin;
5.2.2. Recherche suivant la position de l'élément

Cette recherche retourne l’adresse du l’élément se trouvant à la kième position de la liste s’il
existe et Nil sinon.
Exemple
Étant donnée la liste suivante :
Tête 10
Pour la recherche de l'adresse d'un élément dans cette liste, nous distinguons deux cas de
figures.
Cas 1 :
La recherche d’un élément se trouvant à une position K (K=1,2 ou 3) et qui retourne son
adresse.
Cas 2 :
La recherche d’un élément se trouvant à une position invalide (K>3) et qui retourne la valeur
Nil. La fonction décrivant cette recherche est donnée comme suite :
Fonction adresse (tête : ptr; K : entier) : Ptr;

Début

Tant que (tête <> Nil) et (K>1)

Faire
K ←K-1; tête ←tête^.svt;
Fait;
Adresse ←tête;
Fin;
5.3. Insertion d’un élément

Nous distinguons trois types d’insertion à savoir : au début, à la fin et à une certaine position
K.
5.3.1. Insertion au début
Exemple : insertion de la valaur (-2)
Tête 10

P 10
-2 Nil
Procédure insertion_début (E-S/tête : ptr; val : Entier);

Var
P : Ptr;
Début
Allouer (P);
P^.info ←val;
P^.svt ←tête;
Tête ←P;
Fin;

5.3.2. Insertion à la fin

Tête 10
P 10
-2 Nil 10 Nil 25 23
P 10 7 Nil
Procédure insertion_fin (E-S/tête : ptr; val : Entier);

Var
P : Ptr;
Début
Si (tête <> Nil) alors
P ←Tête;
Tant que (P^.svt <> Nil)
Faire
P ←P^.svt;
Fait;
Allouer (P^.svt); P←P^.svt;
P^.info ←val; P^.svt←Nil;
Sinon insertion_début(tête, val);
Fsi;
Fin;
5.3.3. Insertion au milieu

Tête 10
K-1 K+1
13 Nil 23 Nil
P 10 Q 10 29
Procédure insertion_k (E-S/tête : ptr; val : Entier; K : Entier; possible : booléen);

Var
Q, P : Ptr;

Début
Si (k=1) alors insertion_début (Tête, val); Possible ←vrai;
Sinon P ←adresse (tête, k-1) ;
Si (P<> Nil) alors allouer (Q);
Q^.info ← val;
Q^.svt ←P^.svt;
P^.svt ←Q;
Sinon possible ← faux
Fsi;
Fsi;
Fin;
5.4. Suppression d’un élément

Nous distinguons trois types de suppression à savoir : au début, à la fin, et à une certaine
position K.
5.4.1. Suppression au début
Tête 10
-2 Nil 10 Nil 25 23 Nil

P 10
Procédure suppression_début(E-S/tête : ptr; E/val : Entier; S/possible : booléen);

Var
P : Ptr;
Début
Si (tête <> Nil) alors P ←tête;
Tête ←tête^.svt;
Libérer (P);
Possible ←vrai
Sinon Possible ←faux;
Fsi;
Fin;

5.4.2. Suppression à la fin
Tête 10
P 10
10 Nil 25 23 Nil
Q 10 7 Nil
Procédure Suppression_fin (E-S/tête: ptr; Val: Entier; possible:booléen);

Var
Q, P: Ptr;
Début
Si (tête=Nil) alors possible←faux
Sinon P←tête; Q←tête;
Tant que (Q^.svt <> Nil)
Faire
P←Q;
Q ←Q^.svt;
Fait;
Si (P^.svt <> Nil) alors P^.svt ←Nil
Sinon tête ←Nil
Fsi;
Libérer (Q);
Possible← vrai
Fsi;
Fin;
5.4.3. Suppression au milieu

Tête 10
K-1 K K+1
13 Nil 10 Nil 25 23 Nil
P 10 Q 10

Procédure Suppression_k (E-S/tête : ptr; val : Entier; K : Entier; possible : booléen);

Var
Q, P : Ptr;
Début
Si (k=1) alors suppression_début (Tête, val, possible)
Sinon P ←adresse (tête, k-1);
Si (P<> Nil) alors Q←P^.svt;
Si (Q <> Nil) alors
p Possible←vrai;
P^.svt ←Q^.svt;
p Libérer (Q);
Fsi;
Fsi;
Fsi;
Fin;
6. Listes circulaires
6.1. Définition
Est une liste linéaire chaînées dont le dernier élément de liste pointe sur le premier comme
nous montre le schéma suivant :
Tête 10
10 Nil 25 Nil 23
6.2. Création d'une liste circulaire

Elle consiste à créer d'abord la liste en mode FiFO puis relier enfin le dernier élément au
premier.
Procédure liste_circulaire_fifo (E/T : tab; E/ N : Entier ; S/tête : Ptr);

Début
Allouer (tête); P ←tête;
Pour i ← 1 à N-1
Faire

P^. info ← T[i];

Allouer (P^.svt);
P←P^.svt;
Fait;
P^.info ←T[N];
P^.svt ←tête;
Fin;
6.3. L'affichage du contenu d'une liste circulaire

L'affichage du contenu d'une liste se fait par le parcourt de tous les éléments allant du premier
élément jusqu'à l'obtention de la valeur initiale de la tête.
Procédure affichage_circulaire (E/tête :Ptr);

Var
P: ptr;
Début
si (L=NIL) alors écrire ("Liste vide")
sinon
P←tête;
Répéter
Écrire (tête^. info);
Tête← tête^.svt;
Jusqu'à (tête =P);
fsi;
Fin;
6.4. Recherche d'un élément dans une liste circulaire

La recherche d'un élément en connaissant sa valeur ou bien en connaissant sa position.
6.4.1. Recherche en connaissant la valeur de l'élément
Procédure rechercher_circulaire (E/tête :Ptr; E/ val: entier; s/adresse :Ptr);

Var
P: ptr;
Début
si (L=NIL) alors adresse←NIL;
sinon
P←tête;

Répéter
si (tête^. info=val) alors adresse← tête ; tête← P;
sinon Tête← tête^.svt;
Fsi;
Jusqu'à (tête =P);
Fsi;
Fin;
6.4.2. Recherche en connaissant la position de l'élément
Procédure rechercher_circulaire (E/tête :Ptr; E/ K : entier; s/adresse :ptr);

Var
P: ptr;
Début
si (tête=NIL) alors adresse←NIL;
sinon
P←tête; i←1;
Tant que (k>i) et (tête <> P^.svt )
Faire
Tête← tête^.svt; i←i+1;
Fait;
adresse←tête;
Pour j ← 1 à k Mod i
Faire
adresse← adresse^.svt;
Fait;
Fsi;
Fsi;
Fin;
7. Listes bidirectionnelles
7.1. Définition
Est une liste linéaire chaînée, telque chaque élement de la liste contient deux pointeurs : svt et
pred qui décrivent respectivement le pointeur sur le suivant et sur le précédent.

Tête 10
10 12 25
Nil
Nil
7.2. Création d'une liste bidirectionnelle

Elle consiste à adapter l'algorithme de création d'une liste linéaire simple en mode LIFO en
ajoutant le lien Pred sur les éléments précédents.
Type
ptr=êlt;
elt=Enregistrement
info :entier;
svt, pred :ptr;
Fin;
Procédure liste_bidirectionnelle (E/T : tab; E/ N : Entier ; S/tête : Ptr);

Début
tête ←nil;
Pour i ← 1 à N
Faire
Allouer (P); P^.info←T[i];
P^.svt←L;
si (L<>nil) alors L^.pred← P; fsi;
L←P;
P←P^.svt;
Fait;
L^.pred ←Nil;
Fin;
8. Exemples d'application
Exemple 1
Écrire une action paramétrée permettant de trier une liste d'entiers dans l'ordre croissant du
champ information. Notons que le tri demandé consiste à changer uniquement la valeur des
champs information sans toucher aux liens de chaînage.

Procédure tri_liste (E-S/tête: Ptr );

Var
I, J : Ptr;
V : êntier;
Début
I ←Tête;
Tant que (I<>Nil)
Faire
J ←I^.svt;
Tant que (J<> Nil)
Faire
Si (J^.info > I^.info) alors
Allouer (V);
V^←I^.info;
I^.info ← J^.info;
J^.info ←V^;
Libérer (V)
Fsi;
J←J^.svt;
Fait;
I←I^.svt;
Fait;
Fin;
Exemple 2
Écrire une action paramétrée permettant de calculer la somme des N premiers éléments d’une
liste d'entiers.
Fonction somme (tête: ptr; N : entier): entier;

Var
I, S: Entier;
Début
S←0; I←1;
Tant que (tête<>Nil) et (I<=N)
Faire
S←S+tête^.info;
Tête ←tête^.svt;
I ←I+1
Fait;

Somme ←S;
Fin;

Chapitre IV : Les fichiers séquentiels
1. Introduction
Étant données les renseignements de N enseignants (N<=100), tel que chaque enseignant est
décrit par un NSS (numéro de sécurité sociale), un prénom, un nom, et une date de naissance.
Pour stocker ces informations, nous avons utilisé un vecteur de 100 enregistrements.
Comment faire également pour sauvegarder toutes les informations même après la terminaison
du programme?
Toutes les structures de données vues jusqu’à présent ne répondent plus à ces besoins, car
leur contenu sera perdu juste après la terminaison du programme.
Comme solution, on utilise les fichiers à accès séquentiel.
2. Définition
Un fichier est un ensemble d’informations stockées sur un support physique (disque dur, flash
disque, …). Il s’agit d’une structure de donnée permettant de regrouper et de stocker de
manière permanente, un ensemble infini de variables de même type.
Suivant le mode d’accès à un fichier, nous distinguons deux types de fichier : fichier à accès
séquentiel et fichier à accès direct. Dans ce qui suit nous nous intéressons uniquement aux
fichiers à accès séquentiel.
3. Les caractéristiques d’un fichier à accès séquentiel

Un fichier à accès séquentiel peut être vu comme un ruban de longueur infinie. La lecture et
l'écriture sur ce fichier est réalisée par une tête de lecture/écriture permettant la lecture ou
l’écriture d’un seul élément à la fois. L’élément référencé ou pointé par la tête de
lecture/écriture est appelé l’élément courant.
Tête de lecture/écriture (élément courant)

Marque de fin de fichier
10 2 X ….
Premier élément
Un fichier à accès séquentiel vérifie les conditions suivantes :
1. Les éléments doivent être de même type,

2. L’ajout d’un élément ne peut se faire qu’en fin de fichier,
3. L’insertion et la modification d’un élément ne sont pas permises,

4. Chaque élément a un prédécesseur sauf le premier,

5. Chaque élément a un successeur sauf le dernier,
6. L’accès à un élément nécessite le passage par tous les éléments qui le précédent.
4. Déclaration d’un fichier

Un fichier est décrit par un nom logique et un nom physique. Le premier est visible uniquement
dans le programme (l’algorithme) qui le manipule, alors que le second est utilisé par le système
de gestion de fichier (mémoire secondaire). Un fichier est décrit également par un type qui
correspond à celui de ses éléments.
Mémoire centrale(RAM) Mémoire(Disque dur)

secondaire
Nom_logique Nom_physique
^Nom_logique
(Tampon)
Pour déclarer un fichier logique on suit la syntaxe suivante :
Syntaxe
Var
<idf_fichier_logique> : Fichier de <type_élément>;
<type_élément> peut être soit un type simple ou structuré sauf fichier.
Exemple :
Fich_entier : Fichier de entier;
Remarque :
Si le type des éléments d’un fichier est structuré, il est préférable de le déclarer d’abord dans
la partie type.
Exemple :
La déclaration d’un fichier contenant les renseignements de plusieurs enseignants est donnée
comme suite :

Type
NSS : entier;
Nom, prénom : chaine;
Fin;
Var
Fich_enseignant : Fichier de enseignant ;
Nous pouvons définir aussi un type fich_enseignant comme suit :
Type
NSS : entier;
Nom, prénom : chaîne;
Fin;
Fich_enseignant = Fichier de enseignant ;

Var
F : fich_enseignant ;
5. Les primitives de manipulation de fichiers

Un fichier peut subir plusieurs types de traitements, à savoir : la création, l'ouverture, le
traitement, et la fermeture.
<Assignation d’un fichier >

<L’ouverture d’un fichier >
<Le traitement d’un fichier>
<La fermeture d’un fichier>
Pour chacune de ces étapes on utilise une primitive (procédure ou fonction) bien déterminée.
5.1. L’assignation
L'assignation est une opération qui permet de faire la correspondance entre le nom logique et
le nom physique d’un fichier, pour ce faire on utilise la procédure Assigner ( ).
Syntaxe

Assigner (<idf_nom_logique>,< nom_physique> ) ;

<nom_physique> désigne soit une constante ou une variable de type chaîne de caractères
décrivant le nom physique du fichier, éventuellement avec son chemin d’accès sur le support
de stockage. Le fichier physique est utilisé pour la sauvegarde permanente des données même
après la terminaison du programme (algorithme).
Exemple :
Assigner (fich_etudiant, "c: etudiant.dat")
Chemin ← "c: etudiant.dat";
Assigner (fich_etudiant, chemin) ;
5.2. L’ouverture d’un fichier

Pour pouvoir exploiter un fichier, il faut d’abord l'ouvrir en mode lecture ou écriture.
5.2.1. L’ouverture en mode écriture (Création)

Pour l'ouverture d’un fichier en mode création on utilise la procédure fécrire(). Il s’agit d’une
procédure ayant comme paramètre d’entrée le nom logique du fichier à ouvrir.
Syntaxe
Fécrire (<idf_fichier_logique>);
<idf_fichier_logique> représente une variable décrivant le nom logique du fichier.
Exemple :
Étant donnée la déclaration de l’exemple précédent, pour ouvrir le fichier F en mode écriture
on écrit :
Fécrire (F) ;
<idf_fichier_logique> représente une variable décrivant le nom logique du fichier.
F^
X …. X
Remarque :
Si le fichier est déjà crée, alors toutes les informations que contient seront perdues.
5.2.2. L’ouverture en mode lecture

L’ouverture d’un fichier en mode lecture permet de positionner la tête de lecture/écriture sur
le premier élément de ce fichier. Pour ce faire, on utilise la procédure flire() qui a comme

paramètre d’entrée le nom logique du fichier.
Syntaxe
Flire (<idf_nom_logique>);
Exemple :
L’instruction suivante nous permet d’ouvrir le fichier logique F en mode lecture.
Flire (F)
F^
12 10 X …. 12
5.3. La fermeture d’un fichier

Pour fermer un fichier on utilise la procédure fermer (). La fermeture d’un fichier interdira
toutes les opérations d’entrée/sortie sur ce fichier jusqu’à sa réouverture soit en mode lecture
(flire) ou bien en mode écriture (fécrire).
Exemple :
Fermer (F);
5.4. Les opérations d’entrée/sortie sur un fichier

5.4.1. L’opération d’entrée
Elle consiste à ajouter un nouvel élément à un fichier donné. Notons que l'ajout d'un élément se
fait uniquement en fin de fichier par l'appel de la procédure mettre(). Il consiste à copier le
contenu d’une variable intermédiaire <IDF_ variable> dans le fichier <idf_nom_logique>.
Syntaxe
mettre (<idf_nom_logique>, <IDF_ variable>);
Exemple :
Soit la déclaration suivante :
Fent : fichier de entier;
Dans ce qui suit nous présenterons l’état de la mémoire après chaque instruction.
Fécrire (Fent);
y ←10; y Fent ^
mettre (Fent, y); X …. 10 X
10 X …. 2 X
10 2 X …. 2 X
y←2;
mettre (Fent, y) ;
Remarque
On ne peut plus modifier la valeur d’un élément.
5.4.2. L’opération de sortie

L’opération de sortie ou la lecture d’un élément à partir d'un fichier permet de copier
l’élément courant du fichier <idf _fichier_logique> dans une variable intermédiaire <idf_variable>.
Syntaxe
prendre (<idf _fichier_logique>, <idf_variable>) ;
Exemple : y Fent ^
Flire (Fent) ; 10 2 4 X …. ? 10
prendre (Fent, y) ; 10 2 4 X …. 10 2
prendre (Fent, y); 10 2 4 X …. 2 4
prendre (Fent, y); 10 2 4 X …. 4 X
Remarque
Le programmeur n’intervient plus dans la gestion de la mémoire tampon du fichier Fent ^.
5.5. Marque de fin de fichier

Pour réaliser une opération de lecture à partir d'un fichier, nous devrons bien avant vérifier que
le fichier n’est pas vide et contient au mois un élément. Ceux ci est assuré par la fonction fdf (
) qui retourne la valeur faux si la tête de lecture n'est pas sur la marque de fin de fichier. Il
s'agit d'une fonction booléenne ayant comme paramètre d’entrée le nom logique du fichier à
tester.
Syntaxe
Fdf (<nom_logique>) ;
Exemple :
Pour les deux exemples précédents, la fonction fdf () prendra les valeurs suivantes :

La lecture y Fent ^ Fdf(fent)

10 2 4 X …. ? 10 Faux
10 2 4 X …. 10 2 Faux
10 2 4 X …. 2 4 Faux
10 2 4 X …. 4 X Vrai
6. Exemples d’application
Exemple 1 :
Écrire une action paramétrée permettant la recherche de la valeur et la position du maximum
d’un fichier d’entier.
Solution
Type
Fent = Fichier de entier;
Procédure recherche_maximum (E-S/F : Fent; S/Max, S/Pos : Entier) ;

Début
Assigner (f, ‘f.dat’);
Flire (F);
Si fdf (F)=vrai
alors écrire (‘le fichier est vide’)
sinon
prendre (F, max); i ←1;
Tant que non FdF (F)
Faire
prendre (F, v); i ←i+1;
Si (v > max) alors max ←v; pos ←i
Fsi;
Fait;
Fsi;
Fermer (F)
Fin;
Fin;
Remarque
L’ouverture et la vérification de fin de fichier peuvent se faire avant l’appel de la procédure.

Exemple 2 :
Écrire une action paramétrée permettant de copier le contenu d’un fichier (source) dans un
autre fichier (destination).
Type
Fent=Fichier de entier;
Procédure copier (E-S/ source, destination : Fent);

Var
V : entier;
Début
Assigner (source, ‘source.dat’); Assigner (destination, ‘destination.dat’);
Flire (source); fécrire (destination);
Tant que (fdf (source)=faux)

Faire
prendre (source, v); mettre (destination, v);
Fait;
Fermer (source); Fermer (destination)
Fin;
Exemple 03 :
Écrire une action paramétrée permettant de fusionner deux fichiers (F1 et F2) d’entiers triés
dans l’ordre croissant pour avoir un troisième (F3) trié dans le même ordre.
Procédure fusion (E_S/ F1, F2, F3 : Fent);

Début
prendre (F1,x);
prendre (F2, y);
Tant que non Fdf(F1) et non Fdf(F2)
Faire
Si (x<y) alors mettre (F3, x); prendre (F1, x)
Sinon mettre (F3, y); prendre (F2, y)
Fsi;
Fin;
Tant que non Fdf (F1) et (x<=y)
Faire

mettre (F3, x); prendre (F1, x) ;

Fait;
Tant que non Fdf (F2) et (y<=x)
Faire
mettre (F3, y); prendre (F1, y) ;
Fait;
Si x<y alors mettre (F3, x); mettre (F3, y)
Sinon mettre (F3, y); mettre (F3, x)
Fsi;
Tant que non Fdf (F1)

Faire
prendre(1, x) ; mettre (F3, x);
Fait;
Tant que non Fdf(F2)

Faire
prendre (F2,x); mettre (F3,x)
Fait;
Fin;
Remarque :
L’ouverture des trois fichiers est réalisée avant l’appel de la procédure fusion comme suit :
Assigner (F1,’F1.dat’); assigner (F2,’F2.dat’); assigner(F3,’F3.dat’);

Flire (F1); Flire(F2); fécrire (F3);
Si non fdf (F1) alors si non fdf (F2) alors fusion (F1, F2, F3)
Sinon copier (F1, F3)
Fsi
Sinon si non fdf(F2) alors copier (F2, F3)
Sinon écrire (‘les deux fichiers sont vides’)
Fsi;
Fsi;
Fermer(F1); Fermer(F2); Fermer(F3);

Programmation Et Structures de Données

Transféré par

Informations du document

Titre original

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

Programmation Et Structures de Données

Transféré par

Droits d'auteur :

Formats disponibles

UNIVERSITE DES SCIENCES ET DE LA TECHNOLOGIE HOUARI BOUMEDIENNE

Chapitre II : les pointeurs

Chapitre III : les listes linéaires chaînées

Chapitre IV : les fichiers séquentiels

Chapitre I : Les enregistrements

Comme solution on utilise une struture de données de type enregistrement composé de

USTHB, LIC_MI, programmation et structures de données, 2015/2016 Page : 1

3. Déclaration d'un enregistrement

USTHB, LIC_MI, programmation et structures de données, 2015/2016 Page : 2

4. Les opérations sur les enregistrements

4.1. Référence d'un champ

USTHB, LIC_MI, programmation et structures de données, 2015/2016 Page : 3

<chemin> est le chemin d'accès au champ <identificateur_champ>. Il est composé d'une

4.2. Initialisation d’un champ

Enseignant. NSS ← 27785916087;

4.3. Affichage d’un champ

USTHB, LIC_MI, programmation et structures de données, 2015/2016 Page : 4

écrire (Enseignant. NSS, Enseignant. Nom, Enseignant. Prénom, Enseignant.

5. Emboîtement (imbrication) d’enregistrements

USTHB, LIC_MI, programmation et structures de données, 2015/2016 Page : 5

NSS Nom Prénom D_naissance D_recrutement

Jour mois année Jour mois année

On dit en ce moment que l'enregistrement enseignant engendre directement les deux en

Après le déroulement de cet algorithme nous obtiendrons l’état de mémoire suivant :

USTHB, LIC_MI, programmation et structures de données, 2015/2016 Page : 6

USTHB, LIC_MI, programmation et structures de données, 2015/2016 Page : 7

Avec Enseignant, date_naissance

USTHB, LIC_MI, programmation et structures de données, 2015/2016 Page : 8

Avec Enseignant, date_naissance, date_recrutement

USTHB, LIC_MI, programmation et structures de données, 2015/2016 Page : 9

Écrire (jour, mois, année);

USTHB, LIC_MI, programmation et structures de données, 2015/2016 Page : 10

Sinon vérification ←vrai

USTHB, LIC_MI, programmation et structures de données, 2015/2016 Page : 11

USTHB, LIC_MI, programmation et structures de données, 2015/2016 Page : 12

Chapitre II : Les pointeurs

3. Déclaration d’un pointeur

<type_variable_pointée> représente le type de la variable dynamique pointée par le pointeur

USTHB, LIC_MI, programmation et structures de données, 2015/2016 Page : 15

On peut déclarer aussi un type pointeur comme suit :

4. Les opérations de manipulation de pointeurs

4.2. Initialisation d’une variable pointeur

4.3. Initialisation d’une variable dynamique (pointée)

USTHB, LIC_MI, programmation et structures de données, 2015/2016 Page : 17

4.4. Suppression d’une variable dynamique

Dérouler l’algorithme suivant :

USTHB, LIC_MI, programmation et structures de données, 2015/2016 Page : 18

USTHB, LIC_MI, programmation et structures de données, 2015/2016 Page : 19

Vecteur_ens = tableau [1..100] de ptr_enseignant;

USTHB, LIC_MI, programmation et structures de données, 2015/2016 Page : 20

Chapitre III : Les listes linéaires chaînées

Quoi faire si le nombre d'éléments dépassera 100 ?

3. Déclaration d’une liste

USTHB, LIC_MI, programmation et structures de données, 2015/2016 Page : 21

USTHB, LIC_MI, programmation et structures de données, 2015/2016 Page : 22

10 Nil 25 Nil 23 Nil

23 Nil 25 Nil 10 Nil

4. Création d’une liste chaînée

4.1. Création d’une liste LIFO

1ére étape : Création de la tête de la liste

2éme étape : Création du premier élément de la liste

USTHB, LIC_MI, programmation et structures de données, 2015/2016 Page : 23

3éme étape : Création du deuxième élément de la liste