STRUCTURES DE DONNEES 2

BTS GENIE LOGICIEL, 2ème année

CHAPITRE 1 GENERALITES

Introduction
La façon d’organiser les données traitées par un programme impacte grandement sur la
complexité et les performances de ce dernier. La plupart des bons algorithmes utilisent des
méthodes astucieuses pour organiser les données. Ces techniques sont regroupées sous le
vocable « structures de données ».

Une structure de données est l'implémentation explicite d'un ensemble organisé d'objets,
avec la réalisation des opérations d'accès, de construction et de modification afférentes.

On regroupe les structures de données en plusieurs catégories : les structures de données

séquentielles, les structures linéaires, les tables, les arbres et les graphes.

En fonction de la méthode de gestion de la mémoire utilisée, on distingue les structures de

données statiques des structures de données dynamiques. Ces dernières permettent une
gestion plus fine de la mémoire en limitant les gaspillages de mémoire et en facilitant
l’évolution de la taille des données.

Le choix de la bonne structure de données dépend surtout du problème et des algorithmes à

développer. De plus, on utilise généralement une combinaison de plusieurs types de
structures de données pour adresser efficacement certains problèmes.

M. KENFACK, Support de cours « Structures de données 2 », Page 1 sur 21

1. Structures de données linéaires
Les structures de données linéaires sont des structures qui induisent une notion de
séquence entre les éléments les composant (1er, 2ème, 3ème, suivant, dernier…).

Parmi les structures de données linéaires on retrouve :

• les tableaux,
• les listes chaînées, les piles, les files.

1.1. Les tableaux

Les éléments d’un tableau sont de même type et sont placés de façon contigüe en mémoire.

Pour créer un tableau, à 1 ou 2 dimensions, il faut connaître sa taille qui ne pourra être
modifiée au cours du programme, et lui associer un indice pour parcourir ses éléments.
Pour les tableaux, la séquence correspond aux numéros des cases du tableau. On
accède à un élément du tableau directement grâce à son indice.

Soit le tableau à 1 dimension suivant nommé Tablo : 12 14 10 24

Pour atteindre la troisième case du tableau il suffit d'écrire Tablo[3] qui contient 10, si les
valeurs de l’indice commencent à 1.

La structure de type tableau pose des problèmes pour insérer ou supprimer un

élément car ces actions nécessitent des décalages du contenu des cases du tableau,
ce qui peut prendre beaucoup de temps dans l'exécution d'un programme.

Ce type de stockage peut donc être coûteux en temps d'exécution. Il existe une autre
structure, appelée liste chaînée, qui permet plus aisément d'insérer et de supprimer des
valeurs dans une liste linéaire d'éléments.

1.2. Les listes chaînées

Une liste chaînée est une structure linéaire qui n'a pas de dimension fixe à sa création.
Ses éléments de même type sont éparpillés dans la mémoire et reliés entre eux par des
pointeurs. Sa dimension peut être modifiée selon la place disponible en mémoire. La liste
est accessible uniquement depuis son premier élément.

Pour les listes chaînées la séquence est mise en œuvre par le pointeur porté par chaque
élément qui indique l'emplacement de l'élément suivant. Le dernier élément de la liste ne
pointe sur rien (Nil).

On accède à un élément de la liste en parcourant les éléments grâce à leurs pointeurs.

Soit la liste chaînée suivante (@ indique que le nombre qui le suit représente une adresse)

M. KENFACK, Support de cours « Structures de données 2 », Page 2 sur 21

Pour accéder au troisième élément de la liste il faut toujours débuter la lecture de la liste par
son premier élément dans le pointeur duquel est indiqué la position du deuxième
élément. Dans le pointeur du deuxième élément de la liste on trouve la position du troisième
élément…

Pour ajouter un élément il suffit d'allouer une place en mémoire et de mettre à jour les
pointeurs des éléments.

Il existe différents types de listes chaînées :

• Liste chaînée simple constituée d'éléments reliés entre eux par des pointeurs.
• Liste doublement chaînée
• Liste circulaire

Ces différents types peuvent être mixés selon les besoins.

On utilise une liste chaînée plutôt qu'un tableau lorsque l'on doit traiter des objets
représentés par des suites sur lesquelles on doit effectuer de nombreuses suppressions et
de nombreux ajouts. Les manipulations sont alors plus rapides qu'avec des tableaux.

1.3. Les piles et les files

Les files et les piles sont des séquences particulières qui permettent l'ajout et la suppression
d'éléments uniquement à une des deux extrémités de la liste.

La pile est une structure de liste similaire à une pile d'assiettes où l'on pose et l'on prend au
sommet.

La file est une structure de liste similaire à une file d'attente à une caisse, le premier client
entré dans la file est le premier sorti de celle-ci.

2. les tables de hachage

Fonctionnement d’une table de hachage

Une table de hachage est une structure de données qui permet une association (clé,
élément), où chaque élément est associé à une clé et ou chaque clé correspond à un seul
élément.

M. KENFACK, Support de cours « Structures de données 2 », Page 3 sur 21

Elle consiste en un tableau (la table de hachage) dont les cases sont appelées alvéoles et
une fonction (la fonction de hachage). La fonction de hachage associe à une clé une valeur
de hachage. Elle fait donc correspondre la clé d'un élément à une valeur qui est utilisée
comme index dans la table de hachage pour cet élément.

Le but de cette structure de données est d'accéder le plus rapidement possible à un élément
à partir de sa clé.

Les opérations permises par une table de hachage sont les suivantes :

• insère(H, élt, clé) : insère dans la table de hachage H un élément élt dont la clef est
clé.
• élément recherche(H, clé) : recherche dans la table de hachage H si un élément est
associé à la clef clé et renvoie cet élément.
• appartient(H, clé) : recherche dans la table de hachage H si un élément est associé à
la clef clé.

Lorsque deux clés ont la même valeur de hachage, on dit qu'on a une collision. Ces clés ne
peuvent être stockées à la même position, on doit alors employer une stratégie de résolution
des collisions. Il existe deux méthodes principales pour gérer le problème des collisions : le
chaînage et l’adressage ouvert.

M. KENFACK, Support de cours « Structures de données 2 », Page 4 sur 21

 CHAPITRE 2 LISTES CHAINEES

I- Définition et représentation d’une liste chainée

1. Définition
Une liste chainée est simplement une liste d'objets de même type dans laquelle chaque
élément contient :

- des informations relatives au fonctionnement de l'application, par exemple des noms et

prénoms de personnes avec adresses et numéros de téléphone pour un carnet d'adresse ;
l'adresse de l'élément suivant.

C'est ce lien via l'adresse de l'élément suivant contenue dans l'élément précédent qui fait la
"chaine" et permet de retrouver chaque élément de la liste.

2. Représentation

Typiquement un élément d'une liste chainée, appelé aussi une cellule ou un maillon, est
défini par un enregistrement (structure). Cet enregistrement contient les informations en
relation avec les objectifs de l'application et un pointeur sur l’enregistrement suivant de
même type :

Element = Enregistrement

info : Type de l’information traitée ;

suivant : ^Element ;

FinEnregistrement

Remarque : On utilise aussi le terme de structures récursives pour désigner les structures
linéaires (listes chainées, piles, files) et les arbres.

M. KENFACK, Support de cours « Structures de données 2 », Page 5 sur 21

3. Implémentation
On distingue deux implémentations possibles des listes chainées : l’allocation dynamique de
la mémoire et l’allocation contiguë de la mémoire.

a) Allocation dynamique

Les éléments de la liste sont dispersés en mémoire centrale, l'espace est réservé au fur et à
mesure de la demande grâce aux primitives de gestion de la mémoire (Allouer et Libérer).

b) Allocation contiguë

Les éléments de la liste sont contigus soit dans un tableau en mémoire centrale, soit sur
fichier en accès direct et dont la taille maximum est spécifiée et contrôlée dans le programme.

Pour une allocation contiguë de mémoire les pointeurs sont des entiers qui correspondent à
des indices de tableau ou des positions dans un fichier. La structure de données doit préciser
la taille maximum de la liste et définir deux valeurs :

- une valeur de fin de liste

- une valeur qui indique si une position est libre ou pas

4. Opérations sur les listes

Trois opérations principales sont possibles sur les listes :

• Parcours de la liste
• Ajout d’un élément
• Suppression d’un élément
• Savoir si une liste est vide
A partir de là d’autres opérations vont être obtenues : recherche d’une donnée,
remplacement, concaténation de liste, fusion de listes, etc.

Exercice : Donner les avantages et les limites des listes chainées par rapport aux tableaux.

M. KENFACK, Support de cours « Structures de données 2 », Page 6 sur 21

II- Liste chainée simple
Dans une liste simple,

• Chaque cellule contient en plus des données, un pointeur vers l’élément suivant de la liste.
Le pointeur du dernier élément de la liste a la valeur NIL.
• Une variable, appelée tête ou liste, contient l'adresse du premier élément de la liste
chaînée.
• Lorsque la liste est vide, la tête contient la valeur NIL.
• L’adresse du premier élément défini la liste.

Structures de données utilisées dans cette section

Type ListeNombre = Enregistrement

info : entier ;

suivant : ^ListeNombre

FinEnregistrement

Variable liste : ^ListeNombre ; // déclaration d’une variable liste chainée de nombres

1. Liste Vide
Principe : Une liste est vide si sa tête contient la valeur NIL.

fonction liste_vide(liste : ^ListeNombre) : booleen

Debut

Si(liste = NIL) Alors

retourner Vrai;

Sinon

M. KENFACK, Support de cours « Structures de données 2 », Page 7 sur 21

 retourner Faux ;

FinSI

Fin

2. Parcourt d’une liste

Pour parcourir une liste chainée, il suffit avec un pointeur de prendre successivement
l'adresse de chaque élément de la liste. Au départ le pointeur prend l'adresse du premier
élément, ensuite il prend l'adresse du suivant et ainsi de suite.

procedure imprimer_liste(liste : ^ListeNombre)

Variable p : ^ListeNombre ;

Debut

P  liste ;

Tantque (p != NIL) Faire

Ecrire (p^.info) ;

P  p^.suivant ;

FinTantque

Fin

3. Ajout d’un élément dans la liste

a) Ajout d’un nouvel élément en tête de liste

Etape 1 Commencer par créer une nouvelle cellule et initialiser son champ info.

Etape 2 : Ensuite, le nouvel élément est ajouté au début de la liste : son suivant pointe sur
le premier élément de la liste.

M. KENFACK, Support de cours « Structures de données 2 », Page 8 sur 21

Etape 3 : Enfin, le pointeur "premier" qui donne l'adresse de la liste, ne contient plus
l'adresse du début qui est maintenant dans nouveau, premier doit donc prendre cette
adresse :

Procedure ajout_en_tete(liste : ^ListeNombre, val : entier)

Variable nouveau : ^ListeNombre ;

Debut

Alouer(nouveau) ;

nouveau^.info  val ;

nouveau^.suivant  liste ;

liste  nouveau ;

Fin

b) Ajout d’un nouvel élément en fin de liste

Etape 1 Commencer par créer une nouvelle cellule et initialiser son champ info.

Etape 2. Ensuite deux cas se présentent : la liste est vide ou pas.

 Si la liste est vide le premier prend la valeur du nouveau :

 Sinon se positionner sur le dernier élément de la liste et ajouter le « nouveau » à la
suite.

procedure ajout_en_fin(liste : ^ListeNombre, val : entier)

variable dernier, nouveau : ^ListeNombre ;

Debut

Alouer(nouveau) ;

nouveau^.info  val ;

nouveau^.suivant  NIL

si(liste = NIL) alors

liste  nouveau ;

sinon

dernier  liste ;

M. KENFACK, Support de cours « Structures de données 2 », Page 9 sur 21

 // voyez comme on recherche le dernier élément de liste

tanque (dernier^.suivant != NIL) faire

dernier  dernier^.suivant ; // on incrémente dernier

fintantque

dernier^.suivant  nouveau ;

finsi

Fin

4. Suppression
Nous allons distinguer ici la suppression du premier élément de la liste et la suppression du
dernier élément de la liste.

a) Suppression en tête de liste

On suppose dans les étapes suivantes que la liste n’est pas vide.

Etape 1 : on initialise un pointeur « p » sur le premier élément de la liste

Etape 2 : on fait pointer le premier élément de la liste sur son suivant

Etape 3 : On libère l’emplacement mémoire de p.

procedure supprimer_en_tete(liste : ^ListeNombre)

Variable p : ^ListeNombre ;

Debut

Si (liste != NIL) Alors

P  liste ; // etape1

liste  liste^.suivant ; // etape2

Liberer(p) ; //// etape 3

FinSi

Fin

b) Suppression en fin de liste

On suppose dans les étapes suivantes que la liste n’est pas vide.

On distingue deux cas de figure :

M. KENFACK, Support de cours « Structures de données 2 », Page 10 sur 21

Cas ou la liste a un seul élément :

 Etape 1 : on supprime la zone pointée par le premier élément de la liste  Etape

2 : le premier élément prend la valeur NIL.

Cas ou la liste a plus d’un élément :

 Etape 1 : on trouve l’avant dernier élément de la liste

 Etape 2 : on l’utilise pour supprimer le dernier
 Etape 3 : on met le suivant de l’avant dernier à NIL

procedure supprimer_en_fin(liste : ^ListeNombre)

Variable avantDer : ^ListeNombre ;

Debut

si(liste != NIL) Alors

si( liste^.suivant = NIL) Alors // cas où il y a un seul élément dans la liste

Liberer(liste) ;

liste  NIL ;

sinon // cas où il y a plus d’un élément dans la liste

avantDer  liste;

// ici on recherche l’avant dernier élément de la liste

Tantque (avantDer^.suivant^.suivant != NIL) Faire

avantDer  avantDer^.suivant ;

Fintantque

Liberer(avantDer^.suivant) ;

avantDer^.suivant  NIL ;

finsi

FinSi

Fin

5. Création d’une liste

Dans ce qui suit, nous allons créer une liste chainée d’entiers à partir des données fournit
par l’utilisateur. Le principe général reste le même, quel que soit la source des données
(tableau, fichiers, …)

On peut créer une liste chainée par ajout de nouveaux éléments en tête ou en fin de liste.
M. KENFACK, Support de cours « Structures de données 2 », Page 11 sur 21
 a) Création d’une liste en faisant des insertions en tête
Procedure creation_1(liste : ^ListeNombre)

Variable nouveau : ^ListeNombre ;

Continuer : entier ;

Debut

Continuer = 1 ;

Tantque (continuer = 1) Faire

Alouer(nouveau) ;

Ecrire(‘’Entrer un entier : ‘’) ;

Lire(nouveau^.info) ;

// insertion en tête de la liste

nouveau^.suivant  liste ;

liste  nouveau ;

Ecrire(‘voulez vous continuer ? 1 = oui, o = non ‘’) ;

Lire(continuer) ;

FinTantque

Fin

b) Création d’une liste en faisant des insertions en fin

Procedure creation_2(liste : ^ListeNombre)

Variable nouveau, dernier : ^ListeNombre ;

Continuer : entier ;

Debut

continuer = 1 ;

Tantque (continuer = 1) Faire

Alouer(nouveau) ;

Ecrire(‘’Entrer un entier : ‘’) ;

Lire(nouveau^.info) ;

M. KENFACK, Support de cours « Structures de données 2 », Page 12 sur 21

 // insertion en fin de la liste

si(premier = NIL) alors

liste  nouveau ;

sinon

dernier  liste ;

// recherche du dernier élément de la liste

tantque (dernier^.suivant != NIL) faire

dernier  dernier^.suivant ; // on incrémente dernier

fintantque

dernier^.suivant  nouveau ;

finsi

Ecrire(‘voulez vous continuer ? 1 = oui, o = non ‘’) ;

Lire(continuer) ;

FinTantque

Fin

6) Exercice
En considérant la liste chainée d’entiers ci-dessus, écrire les sous programmes suivant :

a) Fonction qui retourne la taille de la liste (nombre d’éléments de la liste)

b) Fonction de recherche booléenne d’un entier donné dans la liste.
c) Rechercher et afficher tous les nombre pairs contenus dans cette liste
d) Rechercher et afficher le plus petit et le plus grand nombre de la liste
e) Procédure qui augmente de « 1 » tous les multiples de 5 présents dans la liste.
f) Procédure qui supprime l’entier « 10 » s’il est dans la liste
g) Procédure qui supprimer la première occurrence d’un nombre donné de la liste
h) Procédure qui ajoute une nouvelle valeur après la première occurrence d’un nombre
donné de la liste.
i) Procédure qui insère un nouveau nombre à la position « k » de la liste.
j) Procédure qui supprime le nombre à la position « k » de la liste.

NB : pour chacune des questions ci-dessus, proposer une version itérative et une version
récursive.

M. KENFACK, Support de cours « Structures de données 2 », Page 13 sur 21

 III- Liste Circulaire
Une liste chaînée est circulaire lorsque le champ suivant du dernier élément contient
l'adresse du premier.

Exemples :

Exemple de liste simplement chainée circulaire :

IV- Liste doublement chainée

Une liste doublement chainée peut-être parcourue dans les deux sens, du premier au
dernier et inversement :

• Chaque cellule contient en plus des données, un champ suivant qui pointe sur la
cellule suivante de la liste, et un champ precedent qui pointe vers la cellule
précédente de la liste
• Une liste doublement chainée est repérée par les pointeurs tête et queue, qui pointent
respectivement sur le premier et le dernier élément de la liste.
• Le pointeur « precedent » du premier élément ainsi que le pointeur « suivant »
du dernier élément contiennent la valeur NIL.
• Lorsque la liste est vide, « tête » et « queue » ont la valeur NIL.

TD/TP N°1 Gestion d’un carnet d’adresse

Un carnet d’adresses contient des contacts contenant chacun : un nom et un numéro de
téléphone.

1. Proposer une structure de liste chainée pour gérer un carnet d’adresses.

M. KENFACK, Support de cours « Structures de données 2 », Page 14 sur 21

 2. Ecrire les sous programmes suivants destinés à gérer cette liste :
a) Ajouter un nouveau contact
b) Afficher la liste des contacts
c) Rechercher tous les numéros de téléphone d’un contact de nom donné
d) Mettre à jour un contact donné
e) Supprimer un contact du carnet d’adresses

TD/TP N°2 Transport Aérien

Un vol possède un aéroport de départ et une date de départ et un aéroport d’arrivée et une
date d’arrivée. Un voyage est constitué de un ou plusieurs vols successifs.

1. Proposer des structures de données pour représenter un voyage.

2. Ecrire une procédure d’enregistrement d’un voyage
3. Ecrire une procédure qui affiche toutes les informations sur un voyage
4. Ecrire une fonction qui donne le nombre d’escales d’un voyage
5. Ecrire une fonction qui retourne la durée (en nombre de jours) d’un voyage
6. Ecrire une fonction qui donne le plus long vol d’un voyage.

TD/TP N°3 Liste de chevaux de course

Ecrire les instructions qui saisissent puis affichent une liste de chevaux de course. Chaque
cheval est entré séparément par l'utilisateur. Un cheval est défini par un nom, un dossard,
un temps réalisé dans la course, un classement. La liste des chevaux est une liste chainée.
Le programme permet d'ordonner la liste selon le classement des chevaux et de supprimer
des chevaux de la liste.

M. KENFACK, Support de cours « Structures de données 2 », Page 15 sur 21

 CHAPITRE 3 PILES ET FILES

Les piles et les files sont des formes particulières de structures linéaires dans lesquelles les
opérations sont limitées aux extrémités de la structure.

I- Les Piles

1. Définition
Une pile est un ensemble de valeurs ne permettant des insertions ou des suppressions qu’a
une seule extrémité, appelée sommet de la pile.

Concrètement, tout nouvel élément est ajouté au sommet de la pile et toute suppression se
fait au sommet de la pile. Il s'agit donc d'une structure de type LIFO (Last In First Out).

Les piles trouvent de nombreuses applications en informatique notamment en théorie des

langages et automates, en compilation, dans les systèmes d’exploitation (pile d’exécution
d’un programme, …), dans l’évaluation d’expressions arithmétiques, …

2. Représentation
On distingue deux approches pour l’implémentation des piles :

 Les piles statiques : utilisation d’un tableau pour représenter la pile. 

Les piles dynamiques : utilisation des listes chainées.

Quel que soit l’approche utilisée, on utilise la même notation pour représenter graphiquement
une pile :

3. Opérations sur les piles

Les principales opérations possibles sur une pile sont :

 Vérifier si la pile est vide

 Empiler : permet d’ajouter une nouvelle valeur (envoyé en paramètre par l’appelant)
à la pile (au-dessus du sommet et dans le cas d’une pile non pleine) ;
 Dépiler : permet de supprimer une valeur (se trouvant au sommet de la pile) et de la
renvoyer en paramètre. Cette opération n’est possible que si la pile n’est pas vide

M. KENFACK, Support de cours « Structures de données 2 », Page 16 sur 21

Dans ce qui suit, nous utiliseront une pile d’entiers (dans une implémentation dynamique)
Structures de données
Type Element = Enregistrement

Info : entier ;

suivant : ^Element

FinEnregistrement

Type Pile = Enregistrement

sommet : ^Element ;

FinEnregistrement

a) Initialiser une pile

procedure init_pile(pile : Pile)

Debut

pile.sommet  NIL ;

Fin

b) Vérifier si une pile est vide

fonction pile_vide(pile : Pile) : booleen

Debut

Si(pile.sommet = NIL) Alors

retourner Vrai;

Sinon

retourner Faux ;

FinSI

Fin

c) Empiler

Empiler un élément revient à faire une insertion en tête dans la liste chaînée.

procedure empiler(pile :Pile, val : entier)

variable p : ^Element ;

Debut

Alouer(p) ;

p^.info  val ;

M. KENFACK, Support de cours « Structures de données 2 », Page 17 sur 21

 p^.suivant  pile.sommet ;

pile.sommet  p ;

Fin

d) Dépiler

Dépiler revient à faire une suppression en tête en renvoyant la valeur se trouvant au sommet.

Attention ! On ne dépile que si la pile en non vide

fonction depiler(pile :Pile) : entier

variable p : ^Element ;

val : entier ;

Debut

// la piste est supposée non vide

p  pile.sommet ;

val p^.info ;

pile.sommet  pile.sommet^.suivant

Liberer(p) ;

retourner val ;

Fin

TPE : Proposer une implémentation statique (avec tableau) d’une pile d’entiers

M. KENFACK, Support de cours « Structures de données 2 », Page 18 sur 21

 II- Les Files

1. Définition
Une file est un ensemble de valeurs qui a un début (Debut) et une fin (Queue).

Les données sont retirées dans l’ordre où elles ont été ajoutées. Concrètement, tout nouvel
élément est ajouté à la queue de la file et toute suppression se fait au début de la file. Il
s'agit donc d'une structure de type LIFO (Last In First Out).

On retrouve de nombreuses applications des files dans les systèmes d’exploitation

(algorithmes d’ordonnancement des processus, liste de travaux à imprimer, …), dans la
construction de systèmes de réservation, dans l’implémentation des applications serveur
réseau, les messages en attente dans un commutateur de réseau téléphonique, …

2. Représentation
On peut implémenter une file dans un tableau (file statique) ou dans une liste chaînée (file
dynamique). Quel que soit l’approche employée, on peut utiliser la notation suivante pour
représenter graphiquement une file :

3. Opérations sur les files

Les opérations autorisées avec une file sont :

 vérifier si la file est vide ou non.

 enfiler toujours à la queue,
 défiler toujours à la tête si la file n’est pas vide,

Dans ce qui suit, nous utiliseront une file d’entiers (dans une implémentation dynamique)

Structures de données

Type Element = Enregistrement

Info : entier ;

M. KENFACK, Support de cours « Structures de données 2 », Page 19 sur 21

 suivant : ^Element ;

FinEnregistrement

Type File = Enregistrement

tete : ^Element ;

queue : ^Element

FinEnregistrement

a) Initialiser une file

procedure init_file(file :File) Debut

file.tete  NIL ;

file.queue  NIL ;

Fin

b) Vérifier si une file est vide

fonction file_vide(file :File) : booleen

Debut

Retourner (file.tete = NIL) ;

Fin

c) Enfiler
procedure enfiler (file : File, val : entier)

Variable nouveau : ^Element ;

Debut

Alouer(nouveau)

nouveau^.info = val ;

nouveau^.suivant  NIL ;

si (file.tete = NIL) alors // cas où la file est vide

file.tete  nouveau ;

file.queue  nouveau ;

sinon // cas où la file est non vide

file.queue^.suivant  nouveau ;

file.queue  nouveau ;

M. KENFACK, Support de cours « Structures de données 2 », Page 20 sur 21

 finsi

Fin

d) Défiler

Attention ! on ne défile que si la file est non vide.

Fonction defiler(file : File) : entier

Variable p :^Element ;

Val : entier ;

Debut

val  file.tete^.info ;

p  file.tete ;

Si (file.tete = file.queue) alors // cas où il y a un seul élément

file.tete = NIL ;

file.queue  NIL ;

sinon // cas où il ya plus d’un élément dans la file

file.tete  file.tete^.suivant ;

finsi

Liberer(p) ;

retourner val ;

Fin

TPE : Proposer une implémentation statique (avec tableau) d’une file d’entiers

M. KENFACK, Support de cours « Structures de données 2 », Page 21 sur 21