Cours d'Algorithmiques 2 « première année>> by reda

ALGORITHMIQUE2 Département Mathématiques et Informatique

Cours d’Algorithmiques 2 « première année »

2007 - 2008

Sommaire

Algorithmique 2

Chapitre 1 : Les enregistrements .……………………………….…………………………….. 1

Chapitre 2 : Les fichiers séquentiels ………………………………………………………….. 13

Chapitre 3 : Initiation aux pointeurs ………………………………………………………….. 29

Chapitre 4 : Les structures dynamiques ...……………………………………………………. 36

Chapitre 1 :

Les enregistrements

1 ALGORITHMIQUE 2 Chapitre 1 : Les enregistrements

1 - Introduction :

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 types différent et qui se

rapportent si la même entité. Les éléments qui composent un enregistrement sont appelés champs.

2 - Définitions :

Les enregistrements sont des données structurées. Ils permettent de regrouper des données de types

différents au sein d’une même structure. Le type et le nombre de champs peuvent être quelconque. Le type peut

aussi différer d’un champ à l’autre.

3 - Déclaration :

En algorithmique En pascal

type nom enregistrement = enregistrement type nom enregistrement = record

champ1 : type1 champ1 : type1 ;

champ2 : type2; champ2 : type2 ;

champ n : type n; champ n : type n;

fin; end ;

Si deux ou plusieurs champs sont de même type, il suffit de les séparer pas des virgules.

type nom enreg = enregistrement

champ1, champ2, ... : type A ;

champ 3 : type B ;

fin ;

Ex :

type tpersonne = enregistrement

nom : chaine [25] ;

personne : chaine [15] ;

age : entier ;

fin ;

Une fois qu’on a défin i le type structuré, on peut par la suite déclarer des variables d’enregistrements

exactement de la même façon que l’on déclare des variables d’un type de base.

var nom variable : nom enregistrement ;

Ex : pers1, pers2, pers3 : tpersonne ;


4 - L’accès aux champs :

Les éléments d’un tableau sont accessibles à travers leurs indices, les champs d’un enregistrement sont

accessibles à travers leurs noms, grâce à l’opérateur « • ».

nom enreg • nom champ : respectivement la valeur mémorisée dans le champ de l’enregistrement.

Ex :

Pour accéder à l’âge de la variab le pers2, on utilise l’expression : pers2 • age.

Remarque :

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.

Les champs d’un enregistrement, tous envers les éléments d’un tableau sont des variables à qui on peut

faire subir les mêmes opérations (affectation, saisie, affichage).

Exercice :

Ecrire un algorithme permettant la saisie des données concernant les personnes : pers1, pers2, pour

l’affichage de la différence d’âge entre ces deux personnes.

Solution :

algorithme personne x ;

type personne = enregistrement

nom : chaine [15] ;

prénom : chaine [15] ;

age : entier ;

fin ;

aar pers1, pers2, pers3 : personne ;

debut

ecrire (‘faire entrer le nom, prénom et l’âge de la 1ière

personne) ;

si (pers1 • age > pers2 • age) alors

ecrire (‘la différence d’âge est’, pers1 • age – pers2 • age)

si non

ecrire (‘la différence d’âge est’, pers2 • age – pers1 • age) ;

fin si ;

fin.


Remarque :

En pascal, on peut écrire (par read ou write) que des variables de type standard simple.

Ex :

Impossible de faire ; lire (pers1).

Si un champ est lui-même de type enregistrement, on lu i applique les mêmes règles.

Si dans le type personne on avait un champ numéro ; enregistrement composé de sous champs :

banque, guichet, clef.

L’accès au champ clef de numéro de personne se fait par : pers • numéro • clef.

Il n ’existe pas de constante d’un type enregistrement.

Il n ’existe pas d’opérations autres que l’affectation et le passage comme paramètre car les

enregistrements dans la majorité des cas leurs utilisations résident dans l’utilisation de leurs

champs.

Il est parfois possible d’avoir à répéter plusieurs fois le même nom pour l’identification de la

variable, ici pers1, nous disposons pour éviter cela, de l’opération avec ... faire (Dans le cas de

notre exemple).

Syntaxe :


avec nom var : enreg istrement faire with ... do

fin avec ; end ;

Ex :

avec (pers1) faire

lire (nom) ;

lire (prenom) ;

lire (age) ;

fin avec ;

Dans l’instruction, les champs de l’enregistrement seront référencés directement, ce qui évite de répéter

pers1 à chaque fois.

Si l’un des champs contient lui-même un enregistrement et que l’on veut accéder à un champ interne, on

peut imbriquer des « avec ».


Ex :

avec pers1 faire

avec numero faire

Lire (clef) ;

fin avec ;

fin avec ;

5 - Les opérations entre deux enregistrements :

Comme l’affectation fonctionne toujours pour des variables de mêmes types ; la seule opération globale

sur un enregistrement est : recopie le contenu d’un enregistrement r2 dans un enregistrement r1 en écrivant :

r1 r2 ;

Ceci est équivalent et plus efficace que de recopier champ par champ à condition que les deux variab les

soient de même type.

Ex :

pers1 pers2 ;

6 - Les variables structurées mixtes :

6 – 1) Tableaux d’enregistrements :

Il arrive souvent que l’on a à traiter non pas un seul enregistrement mais plusieurs. Par exemple, on veut

traiter un groupe d’étudiants. Donc on ne va pas créer autant de variables de types étudiants (enregistrement)

qu’il y a d’étudiants.

On va créer un tableau regroupant tout les étudiants du groupe. Il s’agit alo rs d’un tableau

d’enregistrement.

Pour la manipulat ion d’un tableau d’enregistrement, considérons le problème suivant :

Problème :

Un étudiant est définie par les informat ions suivantes : un identificateur (entier), un nom (chaine de 30

car), numéro de g roupe (1...4) et une note (0...20).

Ecrire un algorithme qui permet de lire les informations relat ives à 180 étudiants de la section, puis

rechercher et afficher tout les étudiants du groupe 2 ayant une note < 10 (afficher le nom et le prénom).

L’identificateur est 1 pour le 1er

étudiant

2 pour le 2ème

étudiant

3 pour le 3ème

étudiant


Solution :

algorithme tab-enreg ;

type etud = enregistrement

nom, prenom : chaine [30] ;

Id : entier ;

groupe : 1..4;

note : 0..20 ;

fin ;

Tab = tableau [1,..,180] de étud ;

var LMD1 : tab;

i : entier; etud1 : etud;

debut

/*Lecture du tableau étudiant*/

pour i allant de 1 a n faire

avec LMD1 [i] faire

Id 1 ;

lire (nom, prenom, groupe, note) ;

fin avec ;

fin pour ;


si (LMD1 [i] • groupe = 2) et (LMD1 [1] • note < 10) alors

ecrire (LMD1 [i] • nom, LMD1 [i] • prénom) ;

fin si ;

fin pour ;

fin.

6 – 2) Enregistrement de tableaux :

Un enregistrement de tableaux est un enregistrement d’un ou plusieurs champs de type tableau.

Ex :

type enreg = enregistrement

champ1 : type1 ;


champ2 : type2 ;

champ3 : tableau [1..10] de entier ;

chmap4 : type4 ;

fin ;

var enreg : enreg ; i : entier ;

Le ième

élément du tableau est désigné par : enreg • champ3 [i] ;

Exercice :

Chaque étudiant est désigné par sont nom et prénom (chaine [30]), numéro de groupe (1..4), et ses notes

obtenues aux modules (algorithmique, analyse, algèbre, mécanique et bureautique).

Ecrire un algorithme qui permet de lire les enregistrements des 180 étudiants de la première année LMD

et d’afficher les noms et prénom des étudiants admis en 2ème

année (moyenne>10).

Les coefficients des modules sont 1.

Utiliser les noms comme indices du tableau de notes.

Solution :

Algorithme enrg – tab ;

const n = 180 ;

module = (algo, algebre, analyse, mecanique, bureautique) ;

type tab : tableau [algo...Bureautique] de module;

etud = enregistrement


groupe : 1..4 ;

numero : entier ;

note : tab ;

fin ;

tab etud = tab [1..n] de etud ;

var LMD1 : tab etud ;

i, j : entier ; moy, s : reel ;

debut


avec LMD1 [i] faire

numero 1 ;


lire (nom, prenom, groupe) ;

pour i allant de algo a bureautique faire

lire (note [j]) ;

fin pour ;

fin avec ;

fin pour ;

S 0 ;


avec LMD1 [i] faire

pour i allant de algo a bureautique faire

S S + note[j];

fin pour;

moy S/5;

fin avec;

si (Moy >= 10) alors

ecrire (LMD1 [i] • nom, LMD1 [i] • prenom) ;

fin si ;

fin pour ;

fin ;

6 – 3) Enregistrement d’enregistrement :

C’est un enregistrement qui contient un ou plusieurs champs de type enregistrement.

Ex :

type enreg1 = enregistrement

champ1 : type1 ;

champ2 : type2 ;

fin ;

enreg2 = enregistrement

champ1 : type1 ;

champ2 : type2 ;

champ3 : type3 ;Fin ;


var enregistrement : enreg2

Pour accéder au champ ch1 : enregistrement, champ3.

Exercice :

Un étudiant est défini par son nom, prénom : chaine [25] et sa date de naissance (jj : 1...31, mm 1...12, aa :

1980...1989).

Ecrire un algorithme permettant de saisir tous les étudiants de LMD1 et d’afficher les noms et prénoms

des étudiants nés le mois de mars.

Solution :

algorithme enreg – enreg ;

const n = 180 ;

type date = enregistrement

jj : 1..31 ;

mm : 1..12 ;

aa : 1980..1989 ;

fin ;

etud = enregistrement


datenaiss : date ;

fin ;

var etudiant = etud ;

debut

pour i allant de 1 a 180 faire

avec etudiant faire

lire (nom, prenom) ;

avec datenaiss faire

lire (jj, mm, aa) ;

fin avec ;

fin avec ;

si (etudiant • datenaiss • mm) = 3 alors

ecrire (etudiant • nom, etudiant • prenom) ;

fin si ; fin pour ; fin.


6 – 4) Enregistrement à champ variable :

Non seulement les enregistrements ont une structure simple qui permet de nombreuses applications, mais

en plus cette structure n’est pas forcement fixe. Il est possible d’indiquer une partie variable à l’intérieur de la

déclaration se fait à l’aide de la s tructure : selon ... de agissant sur un élément appelé : champ discriminateur.

Ce dern ier doit avoir un type préalablement définie : on indique ensuite les champs que contiendra

l’enregistrement suivant la valeur que prendra le discriminateur.

La part ie variable d ’un enregistrement en dernier.

Syntaxe :

type nom enreg = enregistrement

champ1 : type1 ;

Partie fixe.

champ n : type n ;

selon discriminateur : type discriminateur de

valeur1 : champ1 : type1 ; champ2 : type2 ;

valeur n : (champ1 : type1 ; ...) ;

fin ;

Valeur1 ... valeur n, doivent énumérer les valeurs possibles précises par le discriminateur si l’une des

valeurs ne correspond à aucun champ dans la partie variable, il faut mettre des parenthèses vides. La fin est

comme un enregistrement et (selon de) en pascal est : case .... of.

Ex :

type endroit = (rue, avenue, boulevard) ;

adresse = enregistrement discriminateur.

nom : chaine [30] ;

selon etranger : booleen de

false : (numero : entier ; voie : endroit) ;

nom rue ; chaine [30] ;

code : entier ;

ville : chaine [10] ;

true : (pays : chaine [30] ; francophone : booléen);

fin ;

var personne : adresse ;


debut

avec personne faire

nom Smith ;

etranger true ;

pays USA ;

francophone false ;

fin avec ;

fin ;

Exercice :

On suppose qu’on dispose d’un tableau d’individus de 180 personnes (chaque élément de type adresse).

Le tableau est déjà simplifié.

Ecrire les instructions qui permettent d’afficher le nom et le pays de toutes personnes étrangères parlantes

le français.

Solution :


si (indiv idus [i] • etranger = t rue) alors

si (indiv idus [i] • francophone = true) alors

ecrire (individus [i] • nom ; individus [i] • prenom) ;

fin si ;

fin si ;

fin pour ;

Passage d’enregistrement comme paramètre à un sous programme :

Il est possible de passer tout enregistrement en paramètre à une fonction ou procédure (il n’est pas obligé

de passer tous les champs l’un après l’autre ; ce qui permet de diminuer le nombre de paramètres à passer).


Ex :

fonction diff – age (E1, E2 : personne) : entier ;

debut

si (E1 • age) < (E2 • age) alo rs

diff – age (E2 • age) – (E1 • age)

si non

retourner ((E2 • age) – (E1 • age)) ;

fin si non ;

fin si ;

ecrire (‘différence d’âge est ;’) ;

fin.

Chapitre 2 :

Les fichiers séquentiels

13 ALGORITHMIQUE 2 Chapitre 2 : Les fichiers séquentiels

1- introduction :

Les entrées/sorties des ordinateurs sont la communication d’information entre la mémoire de

l’ord inateur (MC) et ses périphériques (disque, écran, clavier...). Les entrées/sorties se font à l’aide des

fichiers séquentiels.

Les fichiers permettent de stocker des informations de manière permanente sur le disque dur,

ces informations restent même lo rsque l’ordinateur est éteint. L’inconvénient est que ces données ne

sont pas en mémoire, on y accède pas directement. En fait, on va lire et écrire les données une à une sur

le disque.

2- Définition :

Un fichier est une collection de données (souvent de même type) dans lesquelles les données ne

peuvent être lues ou écrites que les une après les autres, en commençant par le début et sans retour

possible en arrivée. Un fich ier peut être vide, il peut avoir une fin ou pas du tout, il peut être ouvert ou

fermé.

3- Définition de type fichier :

Pour utiliser un fichier tout au long d’un programme, il faudra l’identifier par une variable dont

le type est en fonction de l’utilisateur à qui on veut faire des fichiers.

Un fichier séquentiel sera donc structuré selon le type de données qu’il contient et on distingue

3 types de fichiers :

Fichiers textes : qui sont écrits en format texte (chaines, nombres) dans lesquelles on peut

écrire et lire ligne par ligne en utilisant les procédures (write, read) en pascal. Chaque fin

de ligne du fichier se termine par les caractères (retour chariote et passage à la ligne), et

l’utilisateur en pourra donc y écrire et y lire indifféremment des entiers ou des caractères.

Cela dépend du type de paramètre passé ou fonction Entrée/Sortie.

Syntaxe :

var F : texte ;

Fichiers typés (file of) : qui sont des fichiers écrits sur disque telle que les données se

présentent en mémoire, cela assure la vitesse d’accès aux données des fichiers. Mais le

plus grand avantage c’est que l’on obtient des fichiers formatés (organisés) sans format

d’entité, chaque entité contient une collection d’unité logique d’informat ion. On peut lire

directement des variables de type structuré sans avoir à se soucier de divers informations

qu’elles contiennent, ce type de fichiers est probable pour tout les autres.

Syntaxe :

var F : file of type de données ;

Fichiers non typés (file) : qui sont des fichiers dont on ne connaît pas le contenu. N’ayant

aucune informat ion sur la structure.

Syntaxe :

var F : file ;


Remarque :

Le clavier et l’écran sont gérés comme des fich iers particuliers, se sont des fichiers textes et ils

sont toujours ouverts et sans fin.

La façon selon laquelle les données sont organisées dans le fichier détermine le type du fich ier.

Ordre physique = ordre logique => organisation séquentielle.

Enreg istrement de taille fixe portant un numéro qui est relat if au début du fichier =>

organisation relative.

Chaque enregistrement est associé à une clef => organisation indexée.

Un fichier est caractérisé par :

o Identificateur (son nom),

o Un emplacement (lire au support),

o Un contenu de données.

Notion d’identifiant :

Nom externe : c’est le nom du fichier pour système de fichier, du système d’exp loitation considéré.

Ex :

Nom TP.pas

Nom interne : c’est le nom du fichier connu par le programme, il est déclaré par celui-ci :

nom fichier.

Nécessite d’associer le fichier externe avec le fich ier interne => opération d’assignation.

4- Déclaration (file of) :

type type fichier : fichier de type du contenu ;

var nom fichier : type fich ier ;

Ex :

type fich entier : fichier de entier ;

var F : fich entier ;

5- La mémoire tampon :

On distingue par mémoire tampon d’un fich ier F, un « Buffer » (une partie de la mémoire) ayant

le même type que celui définissant le fich ier F.

Pascal standard les note : F^. Mais turbo pascal ne les connaît pas. On utilise à cet effet, une

variable de même type que le type définissant le contenu des éléments des fichiers.

Premier

élément Variable tampon

Dernier

élément

Marque la fin de

fichier.

Algo => (FDF).

Pascal => (EOF).


Grâce à la déclaration : var tampon : entier ; la variable tampon peut être utilisée par lire ou

écrire à (partir) ou (dans) le fichier F.

6- Introduction à la manipulation des fichiers :

Un fichier est une structure de données complexe qui nécessite pour être manipulée, des

fonctions standards dont les paramètres sont les suivants :

1. Un nom de fichier.

2. Buffer (tampon).

6 – 1) L’assignation :

C’est une opération qui consiste à établir un lieu entre un fichier externe sur disque (nom

physique) et un fichier interne (nom logique).

Syntaxe :

assigner (nom logique, nom physique) ;

Ex :

Var nom reel : chaine ;

F2, F1 : fichier de entier ;

debut

assigner (F1,’C:\TP\TP1.pas’) ; /*emplacement sur le

disque*/

lire (nom reel) ;

assigner (F2, nom reel) ;

fin.

6 – 2) Fonction de fin de fichier :

La marque de fin de fichier (FDF, EOF) est un repère de position, permettant de savoir ou l’on

se trouve dans un fichier lorsqu’on accède à celui-ci dans l’ordre.

Il existe en pascal une fonction booléenne prédéfinie, notée EOF (End Of File) qui prend la

valeur « vrai » ou « faux » selon le cas :

Si on tente de lire sur un fichier vide, EOF renvoie « vrai ».

Si le fichier n’était pas vide, EOF renvoie « faux ».

Syntaxe :

FDF (nom logique du fich ier) ; valeur booléenne « true » or « false »

EOF (nom logique du fichier) ;


Ex :

si (non FDF (f)) alors

lire (nom logique, tampon) ;

fin si ;

6 – 3) Primitive d’accès au premier élément :

Avant toute opération sur un fichier, ce dernier doit être ouvert (soit pour le lire ou faire des

MAJ « mises à jours»). On distingue 3 modes d’ouverture :

ouvrir (nom du fichier, mode) ;

En lecture :

Ouvrir le fichier en lecture pour lire le contenu.

Syntaxe :

Algorithmique => ouvrir (nom fichier, lecture) ;

Pascal => reset (nom fichier) ;

Reset prépare le fich ier (nom fichier) déjà crée pour le traitement.

Si le fichier n’existe pas, une erreur d’E/S est gênée.

Le pointeur est pointé au début du fichier.

Ex :

var F : fichier entier ;

debut

assigner (F,’C: \TP\TP.pas’);

ouvrir (F, lecture);

lire (F, tampon) ;

ecrire (tampon) ;

fin.

o En écriture :

Créer un nouveau fichier et écraser l’ancien.

Fenêtre de lecture Marque FDF


Syntaxe :

Algorithmique => ouvrir (nom fichier, écriture) ;

Pascal => rewrite (nom de fich ier) ;

Rewrite permet ;

o D’ouvrir le fichier en créat ion / écriture.

o De créer un fichier qui n’existe pas ou bien en efface son contenu (écrasement).

o De positionner au premier élément.

Ex :

var F : fichier de entier ;

Tampon : entier ;

debut

assigner (F,’C:\TP\TP.pas’);

ouvrir (F, écriture);

lire (tampon);

ecrire (F, tampon);

fin.

En ajout :

Ouvre un fich ier F existant pour rajouter en fin de fichier.

Syntaxe :

Algorithmique => ouvrir (nom de fichier, ajout);

Pascal => append (nom de fich ier);

Append (F) :

Ouvre un fich ier (comme rewrite) ; le pointeur de fichiers est placé à la fin du fichier F. cette

procédure n’autorise que l’addition d’éléments au fichier. La lecture n’est pas possible.

8 5 3 2 1 FDF

Fichier vide

Fenêtre d’écriture

Marque la fin du fichier

Fenêtre d’écriture


Ex :


debut


ouvrir (F, ajout);

/*écrire le fichier ou faire un autre traitement */

fin.

Une fois le fichier est ouvert, on lance les opérations habituelles de lecture et d’écriture.

6 – 4) Opération de lecture / écriture dans un fichier :

Pour les fichiers d’éléments typés, les opérations de lectures / écritures se font élément par

élément.

Lecture : Algorithmique => lire (F, var tampon);

Pascal => read (F, var tampon);

La valeur de fenêtre de lecture est transférée dans « var tampon » sauf si la fenêtre voir (FDF) ;

puis la fenêtre avance.

Ecriture :

Algorithmique => ecrire (F, var tampon);

Pascal => write (F, var tampon);

La valeur de « var tampon » est inscrite dans la fenêtre et cette dernière avance d’une position (à

l’emplacement du pointeur).

Ex :


E : entier ;

debut



lire (F, E);

ouvrir (F, écriture) ;

ecrire (F, E);

fin.


6 – 5) Primitive d’accès à l’élément courant :

Après l’ouverture de fichiers et la lecture du premier élément, on utilise la boucle (tant que) et la

fonction FDF.


tant que (non FDF (F)) faire while (not FDF (F)) do

lire (F, E); read (F, E) ;

fin tant que; end ;

Remarque :

Si le fichier n’est pas ouvert en mode création ou ajout, la marque de fin de fichier (FDF) est

rajoutée automatiquement.

6 – 6) Primitive de fin de fichier :

Ferme le fichier par sécurité. Un fichier doit être fermé dès que possible quand un processus

fin it d’utiliser un fichier, il doit le fermer afin de libérer l’espace système.

Syntaxe :

Algorithmique => fermer (nom de fichier);

Pascal => close (nom de fichier);

Ex :


E : entier ;

debut



tant que (non FDF (F)) faire

lire (F, E);

fin tant que ;

fermer (F);

fin.

Remarque :

Il faut retenir le schéma du squelette standard pour la lecture et l’écriture de fichiers.

Assignation • nom logique / nom physique

Ouvrir le fichier (3 mode) /*une opération à la fo is*/

Fermer le fich ier.


Exercice :

Ecrire un algorithme permettant de créer et de remplir un fich ier par N car. Les cases sont lues à

partir du clavier.

Le nom de fichier sera spécifié par l’utilisateur puis lire et afficher le contenu du fichier.

Solution :

algorithme lecture – écriture ;

type F : fichier de car ;

var fich : F ; carac : car ; N : entier ;

nom reel : chaine [30] ;

debut

lire (nom reel) ;

assigner (fich, nom reel) ; /*faire assigner un nom logique au Nom du fichier lu*/

ouvrir (fich, ecriture) ; /*ouvrir le fichier en création*/

lire (N) ;


lire (carac) ; /* lire carac dans le tampon à partir du fichier*/

ecrire (fich, carac) ; /* inscrire les carac lu dans le fich ier*/

fin pour ;

fermer (fich, carac) ; /*fermer le fichier*/

ouvrir (fich, lecture) ; /*ouvrir le fich ier en lecture*/

tant que (non FDF (fich)) faire /*tq la fin du fichier n’est pas rencontrée*/

lire (fich, carac) ; /*lire dans le tampon carac un caractère*/

ecrire (carac) ; /*affichage de carac sur écran*/

fin tant que ;

fermer (fich) ;

fin.

Exercice :

1. Ecrire un algorithme permettant de créer un fichier avec le nom physique suivant :

’C:\lmd1\etud.dat’. Contenant des enregistrements avec des champs : nom, prénom (chaine

[30]), âge (entier) et numéro de groupe (1..4).

2. Ajouter 10 éléments au fichier.


3. Afficher le nom et le p rénom de tous les étudiants enregistrés dans ce fichier dont le numéro de

groupe est 3.

Solution :

algorithme fichier etude ;

const nbr etud = 120 ;


Nom, prenom : chaine [30] ;

age : entier ;

groupe : 1... 4 ;

fin ;

fich : fich ier de etud ;

var fich lmd: fich;

etud: etud;

debut

assigner (fich lmd,’C:\lmd1\etud.dat’) ; /*assignation du nom logique au

nom physique*/

ouvrir (fich lmd, ecriture) ; /*ouvrir le fichier en écriture*/

pour i allant de 1 a nbr etud faire

avec etud faire

lire (nom, prenom, age, groupe) ; /*lire les champs de

L’enregistrement*/

fin avec ;

ecrire (fich lmd, etud) ; /*écrire l’enregistrement sur le fichier */

fin pour ;

fermer (fich lmd) ; /*fermeture du fich ier*/

/*ajout 10 étudiants au fichier*/

ouvrir (fich lmd’ ajout) ; /*ouvrir le fichier pour ajouter d’autres étudiants*/


avec etud faire

lire (nom, prenom, age, groupe) ;

fin avec ;

ecrire (fich lmd, etud) ;


fin pour ;

fermer (fich lmd) ;

/*lire et afficher les noms et prénoms, des étudiants du groupe 3*/

Ouvrir (fich lmd, lecture) ; /*ouvrir le fich ier en lecture*/

tant que (non FDF (fich lmd)) faire /*tant que fin de fichier non atteinte*/

lire (fich lmd, etud) ; /*lire un élément de fichier (un enregistrement avec

ses 4champs)*/

si (etud • groupe = 3) alors /*tester le champ groupe*/

ecrire (etud • nom, etud • prenom) ; /*afficher à l’écran le nom et le

prénom*/

fin si ;

fin tant que ;

fermer (fich lmd) ; /*fermeture de fichier*/

fin.

7- fichier paramètre d’une fonction ou procédure :

Une variab le de type fich ier peut être un paramètre d’un sous programme (procédure ou

fonction), mais à la d ifférence des autres variables traitées jusqu'à maintenant, un fichier ne peut être

passé que par variable, le compilateur pascal n’accepte pas un fichier passé par valeur à un sous

programme si ce dern ier n’est pas modifié par le sous programme.

Exercice :

Ecrire un algorithme qui permet d ’ajouter des éléments au fichier : ’C:\lmd1\etud.dat’.

L’utilisateur donne l’enregistrement à rajouter, ce dernier sera ajouté aux fichiers, ensuite le

sous programme demande à l’utilisateur s’il veut rajouter d’autres éléments, si la réponse est « o » ou

« O », on lit un nouvel enregistrement qui sera ajouter au fichier et ainsi de suite jusqu’à ce que

l’utilisateur n’à plus d’enregistrement à ajouter.

Solution :

algorithme fichier parametre ;



age : entier ;

groupe : 1...4 ;

fin ;

Lmd = fichier de etud ;

var fich etud : lmd ;


Procedure ajout (var F : lmd)

var rep : chaine ;

eng : etud ;

debut

ouvrir (F, ajout) ;

repeter

avec eng faire

lire (nom, prenom, age, groupe) ;

fin ;

ecrire (F, eng) ;

ecrire (’saisir les coordonnés d’un autre étudiants, 0/N’) ;

lire (rep) ;

Jusqu’à (rep = N) ou (rep = n) ;

fermer (F) ;

fin repeter ;

fin ;

debut /*programme principal*/

assigner (fich etud,’C:\lmd1\etud.dat’) ;

ajout (fich etud) ;

fin.

8- Algorithme traitant un seul fichier :

Le fichier est une structure de données qui existe sur disque. Le temps d’accès au disque est plus

long que celui en MC (10 fo is). En p lus, pour permettre deux enregistrements, il faut connaître leurs

emplacements sur le d isque (leurs positions).

Pour toutes les raisons, il est conseillé de charger les enregistrements du fichier dans un tableau

d’enregistrement, puis trier ce tableau pour écrire enfin ce dernier dans le fichier.

Exercice :

Ecrire un algorithme qui permet de t rier le fichier étudiant selon l’ordre alphabétique croissant

des noms et prénoms de chaque étudiant.


Solution :

algorithmique trie fich ;



age : entier ;

groupe : 1 ... 4 ;

fin ;

fich = fichier de entier ;

var t, E : etud ;

Lmd : fich ;

Tab = tableau [1.. n] de etud ;

Taille, i, k, j : entier ;

debut /*chargement*/

assigner (lmd,’C:\tp.pas’) ;

ouvrir (lmd, lecture) ;

i 1 ;

tant que (non FDF (lmd)) faire

lire (lmd, E);

Tab [i] E;

i i + 1;

fin tant que ;

Taille i – 1 ;

/*trier*/

pour i allant de 1 a (i – 1) faire

pour j allant de (k + 1) a i faire

si (tab [j] • nom) ou (tab [j] • nom = tab [k] • nom) et ((tab [j] •

prenom) < (tab [k] • prenom)) alors

debut

t tab [k] ;

tab [k] tab [j] ;


tab [j] t ;

fin ;

fin si ;

fin pour ;

fin pour ;

fermer (lmd) ;

/*écriture sur le fichier*/

ouvrir (lmd, ecriture) ;

pour k allant de 1 a Taille faire

ecrire (lmd, tab [k]) ;

fin pour ;

fermer (lmd) ;

fin.

9- Algorithme traitant plusieurs fichiers :

Exercice :

Un étudiant est définit par : nom, prénom, âge, groupe et moyenne.

On dispose de deux fich iers : ’C:\lmd1\sectionA.dat’ et ’C:\ lmd1\sectionC.dat’ représentants

respectivement les étudiants des deux sections A et C.

Ecrire un algorithme permettant de fusionner les deux fich iers en un seul de nom physique

’C:\lmd1\ lmd.dat’ puis de calculer les notes des étudiants ayant acquis deux semestres ainsi

que leurs noms et prénoms et la moyenne du meilleur étudiant des deux sections.

Solution :

algorithme exo ;



age : entier ;

groupe : 1... 4 ;

moy : reel ;

fin ;

Fich : fich ier de etud ;

var F, F1, F2: fich;


E: etud;

NM, PM: chaine [25];

nbr, i, entier ;

max : reel ;

debut

assigner (F1,’C:\lmd1\sectionA.dat’) ;

assigner (F2,’C:\lmd1\sectionC.dat’) ;

assigner (F,’C:\ lmd1\ lmd.dat’) ;

ouvrir (F1, lecture) ;

ouvrir (F2, lecture) ;

ouvrir (F, ecriture) ;

tant que (non FDF (F1)) faire

lire (F1, E) ;

ecrire (F, E) ;

fin tant que ;

tant que (non FDF (F2)) faire

lire (F2, E) ;

ecrire (F, E) ;

fin tant que ;

fermer (F1) ;

fermer (F2) ;

fermer (F) ;

ouvrir (F, lecture) ;

nbr 0 ;

max 0 ;

tant que (non FDF (F)) faire

lire (F, E) ;

si (E • moy > 10) alors

nbr nbr + 1 ;

fin si ;


si (E • moy > max) alors

max E • moy ;

NM E • nom ;

PM E • p renom ;

fin si ;

ecrire (’le nombre des étudiants avoir acquit les deux semestres est’, nbr) ;

ecrire (’le nom et prénom du meilleur étudiants est’, NM, PM) ;

ecrire (’sa moyenne est’, max) ;

fin tant que ;

fin.

Chapitre 3 :

Initiation aux pointeurs

29 ALGORITHMIQUE 2 Chapitre 3 : Initiation aux pointeurs

1- Introduction :

Un programme qu i s’exécute utilise au moins deux zones mémoires appelées : segment.

Le segment de données.

Le segment de code : contient les instructions du programme.

Le segment de données est décomposé en trois parties :

1. La zone statique : contient des variables statiques, ie : les variables ayants une durée de vie

égale à celle du programme (c’est le cas des variables globales).

2. La pile : sert à gérer les éléments du programme dont la durée de vie est limitée à un bloc

(c’est le cas des paramètres des appels de fonctions/procédure, variables locales). Elle sert

également à renvoyer les résultats des fonctions.

3. Le tas : tout ce qui reste... un programme ne peut accéder directement aux emplacements

dans le tas. On a besoin donc d’une nouvelle structure de données qui peuvent contenir une

adresse. Ainsi les emplacements sont référencés ensuite à l’aide des : pointeurs .

La mémoire utilisée par les programmes est décomposé en octets (8 bits). Chacun de ces octets

est identifié par un numéro séquentiel appelé adresse. Par convention, une adresse est notée en

hexadécimale, précédé par ox.

Ex :

Déclarer une variable, c’est attribuer un nom ox ffff3A

à une zone, cette zone est :

Données statiques (variable global).

Pile (variab le locale).

1 : Segment de données Tas (tout le reste des déclarations).

2 : Segment de code :

var nom : type ; adresse : représentation hexadécimale

L’adresse d’un code sur (8 bits). Sur (8 bits) : ‘ox ... ‘

Défini par :

Sa position : l’adresse de son premier octet.

Sa taille : nombre d’octets.

Pour accéder à la valeur contenue dans une variable, on utilise simplement son nom, mais il peut

arriver qu’on veuille accéder à l’adresse d’une variable. Dans ce cas, on utilise l’opération d’adresse

suivi du nom de variable.

2- Définition d’un pointeur :

Le type pointeur est simple (comme le réel, entier, ...) il est destiné à contenir l’adresse mémoire

d’une autre variable (dynamique).


On dit qu’une variable pointeur pointe vers une variable dynamique.

3- Déclaration des pointeurs :


1 – type nom pointeur = type de pointeur ; var Pa : ^ type pointeur ;

var Pa : nom pointeur ;

2 – var Pa : type pointeur ;

Ex :

var ptr – x : entier ;

Ptr – x = la variab le pointeur (ord inamyque) de entier

Ex :

A : entier ; /*a : variable entière*/

Pa : entier ; /*Pa : pointeur d’un entier*/

Remarque :

L’accès à la zone statique se fait par les noms.

L’accès au Tas se fait à l’aide des pointeurs.

Les pointeurs : variab les de types particuliers avec une adresse.

Les variab les :

A : est une variable statique.

Pa : est un pointeur.

‘La’ est notée par « Pa ». Est une variable dynamique.

4- Les opérations sur les pointeurs :

4 -1) Création d’un pointeur :

Une variab le dynamique (pointeur) est crée exp licitement pendant l’exécution du programme.

La création (on di aussi allocation) se fait par appel à la procédure « allouer ».

Syntaxe :

allouer (pointeur) ;

new (pointeur) ;

Ex :

algorithme allouer ;

var Pa : entier ;


debut

allouer (Pa) ;

/*réserver une zone de mémoire et mettre son adresse dans le pointeur Pa. Cette

nouvelle zone est la variable dynamique appelée : Pa */

fin.

Après la déclaration d’un pointeur, on lui applique uniquement les 4 opérat ions suivantes :

1- Allouer (P) : mettre P l’adresse de la variable dynamique nouvellement créer.

2- P1 P2 : les deux pointeurs contiennent la même adresse. On dit qu’ils pointent vers la

même variable dynamique (P1 pointera le même objet pointé par P2).

3- P3 Nil /*mettre dans P1 la constante Nil*/. Nil désigne une adresse nulle.

4- On peut comparer P1 et P2 pour égalité ou inégalité (pour vérifier s’ils pointent vers la même

zone).

On peut aussi comparer P1 et P2 à la constante Nil.

Ex :

algorithme creation ;

var Pa, Pb, Pc : entier ; (en pascal : ^ type)

debut

allouer (Pa) ;

Pb Nil ;

Pc Pa ;

si (Pa = Pc) alors

ecrie (’Pa et Pc se pointent cers la même variab le’) ;

fin si ; fin.

Toutes les opérations sur le type de la variab le dynamique peuvent être appliquées (affectation,

lecture, écriture, comparaison).

Ex :

algorithme operation ;

var Pa : entier ;

Pb : reel ;

debut

allouer (Pa) ;

allouer (Pb) ;

Pa 1 ;


Pb 5.5 ;

ecrire (‘le contenue de Pb = ... Pa ) ;

lire (Pb ) ;

fin.

4 -2) Libération d’une variable dynamique (pointeur) :

Une procédure : libérer (nom pointeur) ;

disposer (nom pointeur) ;

La zone occupée par une variable dynamique peut être libérer quand celle-ci devient inutile dans

le programme.

On utilise pour cela l’appel à la procédure « libérer ».

Syntaxe :

algorithme liberer ;

var P1, P2 : entier ;

debut

allouer (P1) ;

allouer (P2) ;

P1 1 ;

P2 5 ;

liberer (P1) ;

P1 P2 ; fin.

Remarque :

1. Un pointeur est associé à un type de variable sur lequel il se pointe.

Ex : P : entier ; pour un pointeur sur entier.

2. Un pointeur est lui-même une variab le et à ce t itre il possède une adresse, alors il ne faut pas

confondre l’adresse de la variable pointeur avec l’adresse contenue dans le pointeur (adresse

de la variable pointée).

3. On utilise un pointeur pour mémoriser l’emplacement d’une autre variab le (@). Il est très rare

d’affecter d irectement une adresse à un pointeur, on affecte généralement une adresse d’une

variable déjà déclaré.

Ex :

var Pr : entier ;

X : entier ;


debut

Pr @X ;

fin.

La valeur ’Nil’ (Not identified link):

Nil est une constante nommée qui désigne une adresse nulle.

In faut toujours initialiser un pointeur. Un pointeur qui n’est pas initialiser s’appelle : un

pointeur pendant.

Un pointeur ’’pendant’’ ne pointe pas « nulle part » mais « n’importe où ».

Le pointeur lui-même est alloué dans la partie statique du segment de données, tandis que

l’emplacement pointé est alloué sur le « tas ».

Remarque :

Pa Pb et Pa Pb

Soit deux pointeurs Pa et Pb qui pointent vers des chaines.

Pa Samia;

Pb Fares;

Pa Pb;

Pa et Pb pointerons vers la même variable.

La variable in itialement pointée par Pa devient inaccessible.

Pa Pb ;

Pa et Pb auront le même contenue.

Exercice :

Ecrire un algorithme permettant de faire la somme de deux variables lues à partir du clavier, en

utilisant les variab les dynamiques.

Solution :

algorithme somme ;

var som ;

debut

allouer (P1) ;

allouer (P2) ;

lire (P1 ) ;

lire (P2 ) ;

S P1 + P2 ;


ecrire (‘La somme est’, S ) ;

liberer (P1) ;

liberer (P2) ;

liberer (S) ;

fin.

Chapitre 4 :

Les structures dynamiques

36 ALGORITHMIQUE 2 Chapitre 4 : Les structures dynamiques

1 - Les listes chainées :

1 – 1) Introduction :

Les structures de données statiques sont de tailles connues à la compilation. Cette taille est citée

explicitement dans la déclarat ion, ainsi la taille est fixe pendant la durée d’exécution du programme.

Cependant, certaines situations en programmat ion nécessitent les structures de données capables

d’évoluer pour l’exécution du programme.

Ex :

Soit la déclarat ion suivante :

const n = 10

var personne : tableau [1..n] de chaine

Limitation 1 :

o Le nombre des personnes doit être connu à la compilation.

o On aimerait bien que nos programmes marchent quelque soit ’’n’’ sans avoir à les changer puis

les recompiler.

Limitation 2 :

o Si le tableau est lu et on veut inverser un nouvel élément en bonne place, on serait obligé de

déplacer d’autres éléments => perte de temps.

Limitation 3 :

o La suppression d’un élément du tableau laisse des trous dans la MC.

o Il est évident que les structures statiques ne peuvent pas répondre à leurs besoins du fait que

leurs tailles soient fixées. La solution est apportée par les structures de données dynamiques

telles que les listes chainées, les piles, ...

Nous nous intéressons dans ce cour sur les listes chainées.

1 – 2) Définition :

C’est une structure de données dynamique avec un accès séquentiel (on ne peut pas accéder à

« i » sans passer par les « i – 1 ») fo rmée de mêmes éléments de mêmes types appelés nœuds .

Liste : <E1, E2, ..., En> ; n ≥ 0.

L’ensemble des nœuds sont chainés (liés) entre eux en utilisant les pointeurs.

1. Une liste est connue par un pointeur de tête qui pointe vers le premier élément dans la liste (son

premier nœud E1)

2. Chaque nœud (Ei) contient l’information à traiter et l’adresse du nœud suivant (un pointeur vers

le mode suivant).

3. Le dern ier nœud (En) n’a pas de suivant (son suivant est l’autre n).


Une liste est vide (n = 0) si sa taille est égale à Nil.

1 – 3) Déclaration :

Il est idéal pour former les nœuds d’une liste.

En effet comme le type enregistrement peut contenir des champs de types différents et le type pointeur

peut être l’un de ces types.

Donc un nœud est un enregistrement à deux champs :

Le premier contient l’information à traiter.

Le deuxième est un pointeur vers le nœud suivant.

Syntaxe :

type type liste = nœud ;

nœud = enregistrement

Inf : type /*n’importe quel type*/

suivant : nœud ;

fin ;

Remarque :

La règle générale dit : il faut définir le type liste et faire référence à un nœud avant de la défin ir,

c’est une exception à la règle.

On peut faire référence au pointeur vers un objet (nœud) avant de définir cet objet.

Comme pour les variab les statiques, on doit définir le type de liste pour les déclarer.

0 2 6 Nil 4 Somme

L’information @ Vers le 2

ème nœud (pointeur).

Somme Premier BET Dernier (Nil)


Ex :

type type liste = personne

personne = enregistrement


age : entier ;

suivant : personne ;

fin ;

Exercice :

On veut créer une liste chainée représentant les étudiants de la section A (120). Un étudiant est

défini par : nom, prénom, âge, adresse.

Ecrire un algorithme permettant de créer cette liste. Le nœud est schématisé :

Algorithmique Pascal Sens

P

P . Info

P . Suivant

P

P^. Info

P^. Suivant

Pointeur vers le nœud

Info à traiter

Pointeur vers le nœud suivant

(même type que P)

Solution :

algorithme creer liste ;

const n = 10 ;

type ma liste = Etudiant ;

Etudiant = enreg istrement


age : entier ;

suiv : ma liste ;

fin ;

var P, L : ma liste ;

Info P

P. suivant P. Info


debut

allouer (P) ;

lire (P • nom, P • p renom, P • ege) ;

L P ;

fin.

1 – 4) Les opérations sur les listes :

1 – 4 – 1) Création :

Une liste commence toujours par un nœud sommet (tête de la liste).

Initialement, la liste est vide. Donc le pointeur sommet pointe sur Nil. Sommet Nil.

La création d’une liste revient à créer au fort et à mesure enchainant les enregistrements (nœuds)

constituants la liste, de telle sorte que le pointeur sommet pointe vers le premier nœud. Le premier

nœud sur le second, et ainsi de suite, le dernier élément ne pointe sur aucun autre nœud do nc, sa partie

pointeur pointe sur Nil.

Pour avoir un nœud en mémoire centrale, il faut allouer de l’espace, alors l’allocation se fait

dans le programme par appel à la procédure :

allouer (nœud)

1 – 4 – 2) La mise à jour :

a) Ajout d’un élément :

a – 1) Au début de liste :

Le rajout d’un élément en tête de liste consiste à changer la valeur du pointeur de sommet par @

(adresse) du nouvel élément et le pointeur du nouvel élément par la valeur initiale du sommet.

Donc : nous avons l’enchainement suivant :

allouer (nouveau) ;

lire (nouv • info) ;

nouv • suiv sommet ;

sommet nouveau ;

A B /

C /

Sommet

Nouveau


a – 2) Ajout en fin de liste :

Le rajout à la fin de la liste consiste à changer le pointeur du dernier élément (Nil) à la valeur de @

du nouvel élément et le pointeur du nouveau à Nil, ce qui le rend le dern ier élément de liste.

P sommet ;

tant que (P • suiv < > Nil) faire

P P • suiv ;

fin tant que;

/*on sortira avec une valeur de P, pointant sur le dern ier élément*/

allouer (nouveau) ;

lire (nouveau • in fo) ;

nouveau • suiv Nil ;

P • suiv nouveau ;

a – 3) Ajout au milieu :

Le rajout d’un élément au milieu d’un emplacement qui n’est ni à la première ni à la dernière

place, consiste à localiser l’élément précédent l’emplacement du nouveau puis faire les affectations

suivantes :

allouer (nouveau) ;

lire (nouveau • info

nouveau • suivant P • suivant ;

P • suivant nouveau ;

Sommet A B

E

C D Nil

Sommet A B /


b) La suppression :

b – 1) Supprimer le premier élément :

La suppression du premier élément consiste à changer le pointeur sommet de telle sorte à ce qu’il

pointe sur le deuxième élément qui devient à son tour le premier élément, sans oublier bien sûr de

libérer l’espace occupé par le premier élément.

Ce qui donne les instructions suivantes :

si (sommet < > nil) alo rs

P sommet ;

sommet P • suivant ;

liberer (P) ;

fin si ;

b – 2) Supprimer le dernier élément :

La suppression du dernier élément consiste à changer le pointeur de l’avant dernier à « Nil » (ce qui

le rend le nouveau dernier élément), puis de libérer l’espace occupé par le dernier élément, ce qui

donne les instructions suivantes :

P sommet ;

Q1 P • suivant ;

tant que (Q1 • suivant < > Nil) faire

P Q ;

Q1 Q • suivant ;

fin tant que ;

/*Si la sortie de la boucle on a : Q1 sera le dernier et б avant dernier*/

P • suivant Nil ;

liberer (Q1) ;

Sommet A B Nil Nil

Sommet A B C Nil


b – 3) Suppression d’un élément au milieu d’une liste :

La suppression d’un élément d’adresse P de la liste qui n’est ni le premier ni le dernier, consiste à

localiser l’élément qui précède P, soit « A », puis de changer les pointeurs comme suit :

A • suivant P • suivant ;

liberer (P) ;

Exercice :

Soit une liste L d’entier.

Créer la liste L à part ir de valeurs tapées sur clavier et terminées par 0 (l’ajout se fait en tête de

liste).

Insérer un élément à la fin de la liste L. la valeur de l’élément doit être à part ir du clavier.

Supprimer le nœud de valeur x, x doit être lu.

Afficher le contenu de la liste.

Solution :

algorithme liste ;

type liste = entier ;

entier = enregistrement

info : entier ;

suiv : liste ;

fin ;

var L, P : liste ;

Val : entier ;

debut

L Nil ;

repeter

allouer (P) ;

lire (val) ;

P • info val ;

P • suiv L ; /*Nil*/

L P ;

Sommet A B C Nil


jusqu’a (val = 0) ; /*ajouter en fin*/

allouer (Q) ;

lire (Q • val) ;

Q • suivant Nil ;

P L ;

tant que (P < > Nil) faire /*parcourir la liste pour pointer sur le

dernier*/

P P • suivant ;

fin tant que ;

P • suivant Q ;

fin.

Cours d'Algorithmiques 2 « première année>> by reda

Documents

Transcript of Cours d'Algorithmiques 2 « première année>> by reda