Professional Documents
Culture Documents
1
Plan
Introduction
Notion de pointeur
Les listes chaînées
Les piles
Les files
Conclusion
2
Introduction
Exemples introductifs
Exemple 1 : Insertion dans un tableau
On dispose d’un tableau T d’entiers déjà rempli de n entiers et de taille
maximale MAX.
On veut insérer un élément e saisi après un entier donné a, si ce dernier
existe dans le tableau, à défaut l’entier e sera mis à la fin du tableau.
Le tableau T a une taille maximale, à un certain moment on peut arriver
à saturation et on ne peut plus insérer : problème des déclarations
statiques (fixes).
3
Introduction (2)
Exemples introductifs (2)
Exemple 2 : Transfert de données d’un fichier à un tableau
On dispose d’un fichier de structure étudiant contenant le numéro
d’inscription, le nom et la moyenne de l’étudiant.
On veut transférer l’ensemble des moyennes >=10 dans un tableau TM de
réels afin d’élaborer des statistiques.
On se confronte à un problème : On ne connait pas à l’avance le nombre
d’étudiants ayant une moyenne >=10 et par conséquent on ne pourra
pas définir la taille de notre tableau à l’avance !
4
Introduction (3)
5
Notion de pointeur
Idée
Jusque-là, et pour représenter les données, nous avons utilisé des
variables de types simples (entier, réel, caractère,…) ou composés
(tableau ou enregistrement) d’une manière statique, c’est-à-dire
l’espace mémoire est réservé au préalable même s’il n’est pas utilisé
en totalité (tel est le cas d’un tableau).
Chaque variable déclarée est reconnue à travers son identificateur
(nom) et aussi son adresse en mémoire.
L’accès à une variable pourrait alors se faire à travers son adresse.
Le contenu d’une variable peut aussi être une adresse, et dans ce cas
cette variable est appelée pointeur.
6
Notion de pointeur (2)
Définition: Un pointeur est une variable spéciale pouvant contenir
l’adresse d’une autre variable.
Objet pointé
Pointeur p
A0F12345
Zone Mémoire
.
.
.
Remarques
Le rôle d'un pointeur est de permettre l'accès à une structure qui serait créée avant
ou lors de l'exécution.
La déclaration doit spécifier le type de base de l'objet qui pourra être accessible à
l'aide du pointeur. 7
Notion de pointeur (3)
Représentation
Il ne s’agit pas de représenter seulement P en tant que variable mais également le
lien existant entre P et l’autre variable.
Si P est un pointeur qui contient l’adresse d’une variable dont le contenu est la
valeur a, on peut alors représenter ce fait par le schéma suivant :
P@
Type
Type_Pointeur = @Objet
Variable
P : Type_Pointeur -- ou directement P: @Objet
Exemples:
Type
Etudiant = Enregistrement
Num : Entier
Nomp : Chaîne[30]
Adr : Chaîne[50]
FinEnregistrement
Variable
Pe: @Etudiant -- Pe: désigne la variable qui contient l’adresse et Pe@: désigne l’objet pointé par Pe
P: @Entier -- P: désigne la variable qui contient l’adresse et P@ : désigne l’objet pointé par P
9
Notion de pointeur (5)
Exercice
On considère deux variables P1 et P2 de type pointeur permettant d’accéder respectivement aux
valeurs a et b. Que donnera l’exécution de l’action P1P2 ?
Situation initiale:
P1 P2
P2@
P1@
a b
P2@, P1@
a b
10
Notion de pointeur (6)
Remarques
L’instruction P1@ P2@: signifie que la variable adressée par P1 contiendra la
valeur contenue dans la variable adressée par P2. Donc la variable adressée par P1
contiendra la valeur b (selon l’exercice précédent).
L’instruction P Nil, initialise un pointeur à une adresse nulle ce qui signifie qu’il
ne pointe aucun objet.
Primitives de manipulation
Pour une variable statique la réservation de la zone mémoire se fait au moment de
la compilation et restera disponible tout au long de l’exécution du programme.
Pour les variables de type pointeur, qui ont l’aspect d’être dynamique, la réservation
de l’espace mémoire se fait au cours de l’exécution du programme à l’aide de la
primitive Allouer: Allouer (P) (P est un pointeur).
Au cours de cette même exécution, si on juge ne plus avoir besoin de cette variable,
on peut s’en passer (la libérer), on utilise alors la primitive Libérer: Libérer (P).
Si P est un pointeur, Allouer (P) signifie qu’on va trouver un emplacement mémoire
libre suffisant pour contenir un objet pointé par P. 11
Les listes chaînées
Introduction
En utilisant les pointeurs, on va implémenter des structures afin de représenter
listes chaînées (qui sont linéaires).
Ces listes peuvent être simplement chaînées, ou doublement chaînées ou circulaires.
Type
TypeElem = … -- TypeElem est un type simple, ou composé,…
Cellule = Enregistrement
Info : TypeElem -- Information utile
Suiv : @Cellule -- Pointeur sur l’élément du suivant
FinEnregistrement
Liste = @Cellule
Variable
L : Liste -- L : @Cellule : une variable d’accès à la liste
-- On a deux champs: L@.Info et L@.Suiv
13
Les listes chaînées (3)
Listes simplement chaînées (3)
Représentation:
Si la liste est composée de la suite (a1, a2, a3,…, an), la cellule contenant ai pointe sur celle contenant ai+1,
pour i = 1, 2, 3, …, n-1. La dernière cellule contenant an n’a pas de successeur et son pointeur aura la
valeur « Nil ».
La connaissance de la première adresse de la chaîne est suffisante pour traiter celle-ci en sa totalité.
Cette adresse doit se trouver dans une variable que nous appellerons très souvent « L ».
Dans le cas d'une liste vide, « L » pointe sur « Nil », et la structure ne contient pas d’autres cellules.
14
Les listes chaînées (4)
Listes simplement chaînées (4)
Exemples de déclaration:
Type
Etudiant = Enregistrement
NCE: Entier -- Numéro de la carte d’étudiant
Nomp: Chaine[30] -- Nom et prénom de l’étudiant
Moy: Réel -- Moyenne générale de l’étudiant
CelluleEt = Enregistrement
Info : Etudiant -- Information relative à un étudiant
Suiv : @CelluleEt -- Pointeur sur l’élément du suivant
FinEnregistrement
ListeEt = @CelluleEt -- Un type liste représentant des étudiants
CelluleNbr = Enregistrement
Nbr: Entier
Suiv: @CelluleNbr
FinEnregistrement
ListeNbr = @CelluleNbr -- Un type liste représentant des entiers
Variable
LE: ListeEt -- L : @CelluleEt : une variable d’accès à la liste
LN: ListeNbr -- -- L : @CelluleNbr : une variable d’accès à la liste
15
Les listes chaînées (5)
Listes simplement chaînées (5)
Primitives sur les listes simplement chaînées: Opérations de base.
1. Initialisation d’une liste: Cette opération doit se faire 3. Taille d’une liste: Permet de déterminer le nombre
avant toute autre opération sur la liste. d’éléments d’une liste (version récursive).
Procédure Init_Liste (Var L : Liste) Fonction Taille (Don L : Liste) : Entier
-- Précondition: - -- Précondition: -
-- Postcondition: transforme la liste L en liste vide -- Postcondition: Taille(L)=Nombre d’éléments de la liste L
Début Début
L Nil Si Vide (L)
Fin Alors Taille 0
Sinon
2. Test de liste vide: Permet de tester si une liste est vide ou Taille 1 + Taille (L@.Suiv)
pas. FinSi
Fonction Vide (Don L : Liste) : Booléen Fin
-- Précondition: -
-- Postcondition : Vérifie si la liste L est vide 4. Premier élément d’une liste:
Début Fonction Premier (Don L : Liste) : TypeElem
Si (L = Nil) Alors Vide Vrai -- Précondition: Non Vide (L)
Sinon Vide Faux -- Postcondition : retourne le premier élément de L
FinSi Début
Fin Premier L@.Info
Fin 16
Les listes chaînées (6)
Listes simplement chaînées (6)
Primitives sur les listes simplement chaînées: Opérations de base.
5. Dernier élément d’une liste: 7. Insertion au ébut d’une liste:
Fonction Dernier (Don L : Liste) : TypeElem Procédure InsérerDébut (Var L : Liste, Don E : TypeElem)
-- Précondition: Non Vide (L) -- Précondition: -
-- Postcondition: retourne le dernier élément de la liste L -- Postcondition: L' ayant tous les éléments de la liste L
Début -- et en tête un élément contenant E
Si (Taille (L) = 1) -- ou L@.Suiv = Nil -- Si L contient (a1, a2, … an), elle devient (E, a1, a2, … an)
Alors Dernier L@.Info -- Premier (L’) =E, Reste (L’)=L et Taille (L’) =Taille (L) + 1
Sinon Dernier Dernier (L@.Suiv) Variable
FinSi c : @Cellule -- ou c : Liste
Fin Début
Allouer (c)
6. Reste d’une liste: c@.Info E
Fonction Reste (Don L : Liste) : Liste c@.Suiv L
-- Précondition: Non Vide (L) Lc
-- Postcondition: renvoie L sans le premier élément Fin
-- Si L contient (a1, a2, … an), Reste(L) = (a2, a3,… an)
Début
Reste L@.Suiv
Fin
17
Les listes chaînées (7)
Listes simplement chaînées (7)
Primitives sur les listes simplement chaînées: Opérations de base.
18
Les listes chaînées (8)
Listes simplement chaînées (8)
Primitives sur les listes simplement chaînées: Opérations de base.
9. Face d’une liste: version récursive 10. Parcours d’une liste: pour affichage ou traitement de
Fonction Face (Don L : Liste) : Liste données.
-- Précondition: Non Vide (L) Procédure ParcoursListe (Don L : Liste)
-- Postcondition: renvoie la liste L sans le dernier élément -- Précondition: Non Vide (L)
-- Si L contient (a1, a2, … an), Face (L) = (a1, a2,…an-1) -- Postcondition: Affiche ou traite les différents
Variable -- éléments de la liste donnée en paramètre
L1 : Liste Variable
Début c : Liste
Si (Taille (L) = 1) -- ou L@.Suiv = Nil Début
Alors Face Nil cL
Sinon L1 Face (Reste (L)) Tant Que (c Nil) Faire
InsérerDébut (L1, Premier (L)) Ecrire (c@.Info) -- ou faire un traitement
Face L1 c c@.Suiv
FinSi FinTantQue
Fin Fin
19
Les listes chaînées (9)
Listes doublement chaînées (LDC)
Définition:
Dans une liste doublement chaînée ou bidirectionnelle, il suffit de connaître l’adresse du premier
élément pour pouvoir accéder à tous les autres (comme dans une liste simplement chaînée).
En plus du pointeur qui donne l’adresse de la cellule ou de l’élément suivant, chaque élément est doté
d’un autre pointeur qui indique l’adresse du précédent. Ceci permet à partir de n’importe quel point
de la liste de connaître les éléments qui se trouvent de part et d’autre.
Représentation:
20
Les listes chaînées (10)
Listes doublement chaînées (2)
Déclaration:
Type
TypeElem = … -- TypeElem est un type simple, ou composé,…
Cellule = Enregistrement
Prec: @Cellule -- Pointeur sur l’élément précedent
Info : TypeElem -- Information utile
Suiv : @Cellule -- Pointeur sur l’élément du suivant
FinEnregistrement
ListeD = Enregistrement
Debut: @Cellule -- Pointeur sur le premier élément
Fin: @Cellule -- Pointeur sur le dernier élément
FinEnregistrement
Variable
LD: ListeD -- Cette liste a pour champs: LD.Debut, LD.Fin
-- A son tour, LD.Debut a les champs: LD.Debut@Prec, LD.Debut@.Info et LD.Debut@.Suiv
-- LD.Fin a les champs: LD.Fin@.Prec, LD.Fin@.Info et LD.Fin@.Suiv
Pour accéder à un élément la liste peut être parcourue dans les deux sens :
en commençant avec la tête, le pointeur Suiv permettant le déplacement vers le prochain élément.
en commençant avec la queue, le pointeur Prec permettant le déplacement vers l'élément précédent.
21
Les listes chaînées (11)
Listes doublement chaînées (3)
Primitives sur les listes doublement chaînées: Opérations de base.
1. Initialisation d’une liste: Cette opération doit se faire avant 3. Taille d’une liste: Permet de déterminer le nombre
toute autre opération sur la liste. d’éléments d’une liste (version récursive).
Procédure Init_Liste (Var LD : ListeD) Fonction Taille (Don LD : ListeD) : Entier
-- Précondition: - -- Précondition: -
-- Postcondition: transforme la liste LD en liste vide -- Postcondition: Taille (LD)=Nbre d’éléments de la liste LD
Début Début
LD.Debut Nil Si Vide (LD)
LD.Fin Nil Alors Taille 0
Fin Sinon
Taille 1 + Taille (LD.Debut@.Suiv)
2. Test de liste vide: Permet de tester si une liste est vide ou FinSi
pas. Fin
Fonction Vide (Don LD : ListeD) : Booléen
-- Précondition: - 4. Premier élément d’une liste:
-- Postcondition : Vérifie si la liste LD est vide Fonction Premier (Don LD : ListeD) : TypeElem
Début -- Précondition: Non Vide (LD)
Si (LD.Debut = Nil) Alors Vide Vrai -- ou LD.Fin=Nil -- Postcondition : retourne le premier élément de LD
Sinon Vide Faux Début
FinSi Premier LD.Debut@.Info
Fin Fin
22
Les listes chaînées (12)
Listes doublement chaînées (4)
Primitives sur les listes doublement chaînées: Opérations de base.
5. Dernier élément d’une liste: C’est plus simple à retrouver 7. Face d’une liste: C’est plus simple à retrouver qu’avec une
qu’avec une liste simplement chaînée. liste simplement chaînée.
Fonction Dernier (Don LD : Liste) : TypeElem Fonction Face (Don LD : ListeD) : ListeD
-- Précondition: Non Vide (LD) -- Précondition: Non Vide (L)
-- Postcondition: retourne le dernier élément de la liste LD -- Postcondition: renvoie la liste L sans le dernier élément
Début -- Si LD contient (a1, a2, … an), Face (LD) = (a1, a2,…an-1)
Premier LD.Fin@.Info Variable
FinSi LF: ListeD
Fin Début
LF.Debut LD.Debut
6. Reste d’une liste: LF.Fin LD.Fin@.Prec
Fonction Reste (Don LD : ListeD) : ListeD Face LF
-- Précondition: Non Vide (LD) Fin
-- Postcondition: renvoie LD sans le premier élément
-- Si LD contient (a1, a2, … an), Reste (LD) = (a2, a3,… an)
Début
Reste LD.Debut@.Suiv
Fin
23
Les listes chaînées (13)
Listes doublement chaînées (5)
Primitives sur les listes doublement chaînées: Opérations de base.
24
Les listes chaînées (14)
Listes doublement chaînées (6)
Primitives sur les listes doublement chaînées: Opérations de base.
25
Les listes chaînées (15)
Listes doublement chaînées (7)
Primitives sur les listes doublement chaînées: Opérations de base.
12. Suppression en fin de liste 13. Parcours inverse: parcourir la liste à partir de la fin
Procédure SupprimerFin (Var LD: ListeD) Procédure ParcoursInv (Don LD : ListeD)
-- Précondition: - -- Précondition: Non Vide (LD)
-- Postcondition: L’élément à la fin est supprimé -- Postcondition: Affiche ou traite les différents
-- Si la liste contient un seul élément il faut mettre à jour -- éléments de la liste donnée en paramètre en faisant
-- le pointeur de début LD.Debut et la liste devient vide -- le parcours à partir de la fin
Variable Variable
s: @Cellule c : Liste
Début Début
s LD.Fin c LD.Fin
LD.Fin LD.Fin@Prec Tant Que (c Nil) Faire
Si (LD.Fin = Nil) Ecrire (c@.Info) -- ou faire un traitement
Alors LD.Debut Nil c c@.Prec
FinSi FinTantQue
Libérer (s) Fin
Fin
26
Les listes chaînées (16)
Listes circulaires
Définition:
La liste circulaire est une sorte de liste simplement ou doublement chaînée, qui comporte une
caractéristique supplémentaire, "elle n'a pas de fin".
Pour rendre la liste sans fin, le pointeur suivant du dernier élément pointera sur le premier élément
de la liste au lieu de la valeur Nil, que nous avons vu dans le cas des listes simplement et doublement
chaînées.
Dans les listes circulaires, nous n'arriverons jamais à une position depuis laquelle nous ne pourrons
plus nous déplacer. En arrivant au dernier élément, le déplacement recommencera au premier
élément. En bref, il s'agit d'une rotation.
Représentation:
Type
TypeElem = … -- TypeElem est un type simple, ou composé,…
Cellule = Enregistrement
Info : TypeElem -- Information utile
Suiv : @Cellule -- Pointeur sur l’élément du suivant
FinEnregistrement
Liste = @Cellule
Variable
L : Liste -- L : @Cellule : une variable d’accès à la liste
-- On a deux champs: L@.Info et L@.Suiv
28
Les listes chaînées (18)
Listes circulaires (3)
Quelques traitements
29
Les piles
Définition
La structure de pile est une structure de liste particulière permettant d’exprimer le
comportement d’une pile d’assiettes: on peut ajouter et enlever des assiettes au
sommet de la pile; toute insertion ou retrait d’une assiette en milieu de pile est une
opération qui comporte de risque (la pile s’écroule).
La stratégie de gestion d’une pile est dernier arrivé, premier servi. En anglais on
dira « Last In First Out », plus connu sous le nom de « LIFO ». Le dernier élément
d’une pile est appelé Base de la pile; le premier élément est appelé Sommet de la
pile. Les opérations de mise à jour (insertion et suppression), d'après la définition,
se font à partir du sommet.
Exemple d’utilisation des piles: Les algorithmes à essais successifs reposent
fréquemment sur la récursivité et ont besoin de sauvegarder la situation avant un
essai pour pouvoir y revenir si cet essai est terminé. Cette sauvegarde s'effectue
dans une pile puisque tout retour en arrière doit ramener à la situation la plus
récente.
30
Les piles (2)
Représentation
P
a4 Sommet de la pile
a3
a2
a1 Nil Base de la pile
31
Les piles (3)
Déclaration
Type
TypeElem = … -- TypeElem est un type simple, ou composé,…
Cellule = Enregistrement
Info : TypeElem -- Information utile
Suiv : @Cellule -- Pointeur sur l’élément du suivant
FinEnregistrement
Pile = @Cellule
Variable
P : Pile -- P : @Cellule : une variable d’accès à la pile
-- On a deux champs: P@.Info et P@.Suiv
32
Les piles (4)
Primitives sur les piles: Opérations de base
1. Initialisation d’une pile:
Procédure InitPile (Var P: Pile)
-- Précondition: - 3. Sommet d’une pile:
-- Postcondition: transforme la pile P en pile vide Fonction Sommet (Don P: Pile) : TypeElem
Début -- Précondition: Non PileVide (P)
P Nil -- Postcondition: retourne l’élément au sommet de P
Fin Début
Sommet P@.Info
2. Test de pile vide: Fin
Fonction PileVide (Don P: Pile) : Booléen
-- Précondition: -
-- Postcondition: retourne vrai si P est vide et faux sinon
Début
PileVide (P = Nil)
Fin
33
Les piles (5)
Primitives sur les piles (2): Opérations de base
4. Ajout d’un élément: Empiler un élément (au sommet) 5. Suppression d’un élément: Dépiler un élément (le
Procédure Empiler (Var P : Pile ; Don E : TypeElem) sommet)
-- Précondition: - Procédure Depiler (Var P : Pile ; Var E : TypeElem)
-- Postcondition: P' ayant tous les éléments de la pile P -- Précondition: Non PileVide (P)
-- et en tête un élément contenant E. -- Postcondition: P' ayant tous les éléments de la pile P
-- Si P contient (a1, a2, … an), elle devient (E, a1, a2, … an) -- sans le sommet
Variable -- Si P contient (a1, a2, … an), elle devient (a2, … an) et E=a1
c : Pile Variable
Début c : Pile
Allouer (c) Début
c@.Info E cP
c@.Suiv P E P@.Info
Pc P P@.Suiv
Fin Libérer (c)
Fin
34
Les files
Définition
Une file est un type particulier de liste, où les éléments sont insérés en queue et
supprimés en tête.
Le nom vient des files d’attente à un guichet, où le premier arrivé est le premier
servi, ce qui justifie le terme anglo-saxon de « FIFO » (First In First Out).
Les files sont d’un usage très répandu dans la programmation système.
Les opérations sur une file sont analogues à celles définies sur les piles, la principale
différence provenant du fait que les insertions se font en fin de liste plutôt qu’en
début.
35
Les files (2)
Représentation
Étant donné que l’insertion se fait toujours en dernière position, il est commode,
afin d’accélérer l’algorithme, de disposer du pointeur sur la dernière cellule de la
file d’attente.
On peut définir une file comme la donnée de deux pointeurs : un premier sur la tête
de file et un second sur la queue. On représente donc une file d’attente par:
36
Les files (3)
Déclaration
Type
TypeElem = … -- TypeElem est un type simple, ou composé,…
Cellule = Enregistrement
Info : TypeElem -- Information utile
Suiv : @Cellule -- Pointeur sur l’élément du suivant
FinEnregistrement
File = Enregistrement
tête : @Cellule -- tête pointe sur l’élément de début
queue : @Cellule -- queue pointe sur l’élément de fin
FinEnregistrement
Variable
F : File -- une variable d’accès à la file
-- on F.tête et F.queue de type pointeur sur cellule
37
Les files (4)
Primitives sur les files: Opérations de base
1. Initialisation d’une file: 3. Tête d’une file:
Procédure InitFile (Var F: File) Fonction Tête (Don F: File) : TypeElem
-- Précondition: - -- Précondition: Non FileVide (F)
-- Postcondition: transforme la file F en file vide -- Postcondition: retourne l’élément à la tête de F
Début Début
F.tête Nil Tête F.tête@.Info
F.queue F.tête Fin
Fin
4. Queue d’une file:
2. Test de file vide: Fonction Queue (Don F: Pile) : TypeElem
Fonction FileVide (Don F: File) : Booléen -- Précondition: Non FileVide (F)
-- Précondition: - -- Postcondition: retourne l’élément à la fin de F
-- Postcondition: retourne vrai si F est vide et faux sinon Début
Début Queue F.queue@.Info
FileVide (F.tête = F.queue Et F.Tête = Nil) Fin
Fin
38
Les files (5)
Primitives sur les files (2): Opérations de base
5. Ajout d’un élément dans une file: L’ajout se fait à la fin, il 6. Suppression d’un élément d’une file: Elle se fait toujours
s’git d’enfiler un élément. en tête, il s’agit de défiler un élément de la file.
Procédure Enfiler (Var F : File, Don E : TypeElem) Procédure Défiler (Var F : File, Var E : TypeElem)
-- Précondition: - -- Précondition: Non Vide (F)
-- Postcondition: F' ayant tous les éléments de la file F -- Postcondition: F' ayant tous les élts de F sans le 1er élt
-- et en queue un élément contenant E -- Si F contient (a1, a2, … an), elle devient (a2, … an) et E=a1
-- Si F contient (a1, a2, … an), elle devient (a1, a2, … an, E) Variable
Variable c : @Cellule
c : @Cellule Début
Début c F.tête
Allouer (c) E F.tête@.Info
c@.Info E F.tête F.tête@.Suiv
c@.Suiv Nil Si (F.tête = Nil)
Si (FileVide (F)) Alors F.queue Nil
Alors F.tête c FinSi
Sinon F.queue@.Suiv c Libérer (c)
FinSi Fin
F.queue c
Fin
39
Conclusion
40
A Suivre…
41