Chapitre 18 - Piles Et Files

Programmation C++ 31/10/2017
Piles et Files (Queues)

Sommaire
Chapitre 18 – Piles et Files (Queues)
• Introduction au TAD Pile (Stack ADT)
Programmation C++ • Les piles dynamiques
• La STL Container stack
• Introduction au TAD File (Queue ADT)
Par • Les files dynamiques
Siaka Fofana
• Les STL Containers deque et queue
fsiaka@hotmail.com
Laboratoire des Signaux et Systèmes • Elimination de la récursivité
Copyright
Copyright ©© 2017
2014, Siaka
2008 Fofana,
Pearson Laboratoire
Education, des Signaux
Inc. Publishing et Systèmes.
as Pearson Université FHB Côte d’Ivoire
Addison-Wesley Copyright
Copyright©©2014,
2017 2008 Fofana, Education,
SiakaPearson LaboratoireInc.
desPublishing
Signaux etasSystèmes. Université FHB Côte d’Ivoire
Pearson Addison-Wesley
Piles et Files (Queues) Piles et Files (Queues)

Introduction au TAD Pile Introduction au TAD Pile
Eléments de base sur les piles
• Une pile est généralement implémentée sous forme de
liste avec seulement possibilités d’ajouts et de retrait au
• Pile: une structure de données LIFO (last in, first out) niveau d’un seul bout de la liste
• Exemples: • Le bout actif d’une liste implémantant une pile est le

– zone de services des assiettes dans une cafétariat sommet (top) de la pile
– retour des adresses lors des appels de fonction • Les types de pile:
– Statique – taille fixe, souvent implémentée à l’aide d’un tableau
– Dynamique – taille variable, souvent implémentée à l’aide d’une liste

chaînée
Copyright
Copyright©©2014,
desPublishing
Pearson Addison-Wesley Copyright
Copyright©©2014,
desPublishing
1

Opérations et fonctions sur une pile Implémentation d’une pile statique
• On utilise un tableau de taille fixe
Opérations:
– push: ajout d’une valeur au sommet de la pile • Le bas de la pile est à l’index 0. Une variable appelée
– pop: retrait d’une valeur au sommet de la pile sommet suit le sommet courant de la pile
const int TAILLE_PILE = 3;
Fonctions: char p[TAILLE_PILE];
int sommet = 0;
– isEmpty: vraie si la pile ne contient aucun élément
– isFull: vraie si la pile est pleine, utilisable seulement pour les piles
le sommet est l’emplacement où l’élément suivant sera
statiques
ajouté
Copyright
Copyright©©2014,
desPublishing
Copyright©©2014,
desPublishing

Exemple d’implémentation avec un tableau Exemple d’implémentation avec un tableau
Cette pile a une capacité max de 3, initiallement sommet = 0 Après trois pops, sommet est 0 et la pile est vide
et la pile est vide.
K K K
push('E'); push('K'); push('G'); pop(); pop(); pop();
E E E (retire G) E (retire K) E (retire E)
sommet est 1 sommet est 2 sommet est 3
Copyright
Copyright©©2014,
desPublishing
Copyright©©2014,
desPublishing
2

Implémentation du tableau Implémentation du tableau
char p[TAILLE_PILE]; char p[TAILLE_PILE];

int sommet = 0; int sommet = 0;
Pour verifier si la pile est vide: Pour verifier si la pile est pleine:
bool isEmpty() bool isFull()

{ {
if (sommet == 0) if (sommet == TAILLE_PILE)
return true; return true;
else else
return false; return false;
} }
Copyright
Copyright©©2014,
desPublishing
Copyright©©2014,
desPublishing

Implémentation du tableau Implémentation du tableau
Pour ajouter un élément à la pile: Pour retirer un élément de la pile:
void push(char x) void pop(char &x)

{ {
if (isFull()) if (isEmpty())
{ {
error(); error();
exit(1); exit(1);
} }
// ou lancer une exception // ou lancer une exception
s[sommet] = x; sommet--;
sommet++; x = p[sommet];
} }
Copyright
Copyright©©2014,
desPublishing
Copyright©©2014,
desPublishing
3

Implémentation de la classe Exceptions venant des opérations sur les piles
class PILE • Des classes d’exception peuvent être ajoutées à la
{ definition de l’objet pile (stack) afin de pouvoir gérer les cas
private: d’une tentative de push sur une pile pleine (overflow) ou
d’une tentative de pop sur une pile vide (underflow).
char *p;
int capacite, sommet;
public: • Les programmes qui utilisent les opérations push et pop
doivent effectuer cela à l’interieur d’un bloc try.
void push(char x);
void pop(char &x);
• les blocs catch doivent suivre le bloc try pour interpreter
bool isFull(); ce qui est survenu et informer l’utilisateur.
bool isEmpty();
PILE(int stackSize);
~PILE()
};
Copyright
Copyright©©2014,
desPublishing
Copyright©©2014,
desPublishing

Les piles dynamiques Les piles dynamiques
Implémentation d’une liste dynamique
• Définir une classe de liste chaînée dynamique
• Implementées sous forme de listes chaînées
• Dans cette classe définir un membre private pour les
noeuds dynamiques de la liste
• Peuvent croitre et décroitre si nécessaire
• Définir un pointeur sur le début de la liste chaînée qui
servira de sommet de pile
• Ne peuvent jamais être plein tant qu’il y a de la
mémoire disponible
Copyright
Copyright©©2014,
desPublishing
Copyright©©2014,
desPublishing
4

Implémentation d’une pile dynamique Opérations sur une pile dynamique
Vérifier si la pile est vide:
Une pile chaînée après trois opérations push: bool isEmpty()
push('a'); push('b'); push('c'); {
if (sommet == NULL)
return true;
else
c b a NULL return false;
}
sommet
Copyright
Copyright©©2014,
desPublishing
Copyright©©2014,
desPublishing

Opérations sur une pile dynamique Opérations sur une pile dynamique
Ajouter un nouvel élément à la pile: Retirer un nouvel élément de la pile:
void push(char x) void pop(char &x)

{ {
sommet = new PNoeud(x, top); if (isEmpty())
{ error(); exit(1);}
}
x = sommet->valeur;
PNoeud *ancienSommet = sommet;
sommet = sommet->suivant;
delete ancienSommet;
}
Copyright
Copyright©©2014,
desPublishing
Copyright©©2014,
desPublishing
5

La STL du container stack La STL du container stack
• Le template stack peut être vu comme une implémentation • Le template stack peut être vu comme une implémentation
sous forme d’un vector, d’une list ou d’une deque sous forme d’un vector, d’une list ou d’une deque
• Il implémente les fonctions membres push, pop et empty • Il implémente les fonctions membres push, pop et empty
• Il implémente d’autres fonctions membres: • Il implémente d’autres fonctions membres:

– size: nombre d’éléments dans la pile – size: nombre d’éléments dans la pile
– top: référence sur l’élément au sommet de la pile (doit être utilisée – top: référence sur l’élément au sommet de la pile (doit être utilisée
avec pop pour retirer et récupérer l’élément au sommet) avec pop pour retirer et récupérer l’élément au sommet)
Copyright
Copyright©©2014,
desPublishing
Copyright©©2014,
desPublishing

La STL du container stack Introduction à la TAD file (queue)
Définition d’une pile à partir de la STL
• File: une structure de données FIFO (first in, first out).
• Defintion d’une pile de char nommée cstack implémentée à
l’aide d’un vector:
stack< char, vector<char> > cstack; • Exemples:
– une file de personnes en attente devant un guichet de banque
• Implementée à l’aide d’une liste: – les demandes d’impression envoyées vers une imprimante d’un
stack< char, list<char> > cstack; réseau
• Implementée à l’aide d’une file deque (par défaut):

• Implementation:
stack< char > cstack;
– statique: taille fixe, implémentée sous forme de tableau
• Les espaces sont nécessaires entre les symboles > > – dynamique: taille variable, implémentée sous forme de liste
consécutifs pour faire la distinction avec l’extraction de stream
Copyright
Copyright©©2014,
desPublishing
Copyright©©2014,
desPublishing
6

Introduction à la TAD file (queue) Introduction à la TAD file (queue)
Disposition et opérations sur les files Implémentation d’une file sous forme de tableau
• rear (arrière): emplacement où les éléments sont ajoutés Une file vide qui peut contenir des valeurs char:
• front (avant): emplacement à partir duquel les éléments

sont retirés
avant, arrière
• enqueue (enfliler): ajouter un élément en arrière de la file enqueue('E');
• dequeue (defiler): retirer un élément à partir de l’avant E

de la file
avant arrière
Copyright
Copyright©©2014,
desPublishing
Copyright©©2014,
desPublishing

Implémentation d’une file sous forme de tableau Implémentation d’une file sous forme de tableau
enqueue('K'); dequeue(); // retirer E

E K K G
avant arrière avant arrière

enqueue('G'); dequeue(); // retirer K
E K G G
avant arrière
avant arrière
Copyright
Copyright©©2014,
desPublishing
Copyright©©2014,
desPublishing
7

Problèmes d’implémentation avec les tableaux Problèmes d’implémentation avec les tableaux
• Dans l’exemple précédent l’avant ne bouge jamais.
• Variables nécessaires
• Chaque fois que dequeue est appelée toutes les entrées const int QSIZE = 100;
restantes dans la file se déplacent d’une position. Cela
prend du temps. char q[QSIZE];
int avant = -1;
int arriere = -1;
• Approche alternative:
int nombre = 0; //nbre elmts dans file
– Tableau circulaire: avant et arriere se déplacent
tous lorsque des éléments sont ajoutés ou retirés. Les • On peut rendre ces données membres d’une classe file
deux peuvent bouger de l’avant vers l’arrière et les opérations seront alors des fonctions membres
• D’autres conventions sont possible
Copyright
Copyright©©2014,
desPublishing
Copyright©©2014,
desPublishing

La fonction membre isEmpty La fonction membre isEmpty
Vérifier si la file est vide Vérifier si la file est pleine
bool isEmpty() bool isFull()

{ {
if (nombre > 0) if (nombre < QSIZE)
return false; return false;
else else
return true; return true;
} }
Copyright
Copyright©©2014,
desPublishing
Copyright©©2014,
desPublishing
8

enqueue et dequeue enqueue et dequeue
• Pour enfiler (enqueue), nous devons ajouter un élément • Pour defiler (dequeue), nous devons retirer un élément
x à l’arière de la file x de l’avant de la file
• La convention des files (Queue) dit que q[arriere] • La convention des files (Queue) dit que q[aavant] est
est déjà occupé. déjà retiré.
if(!isFull) if(!isEmpty)
{ arriere = (arriere + 1) % QSIZE; { avant = (avant + 1) % QSIZE;
// opérateur mod pour revenir // opérateur mod pour revenir
q[arriere] = x; x = q[avant];
nombre ++; nombre --;
} }
Copyright
Copyright©©2014,
desPublishing
Copyright©©2014,
desPublishing

enqueue et dequeue enqueue et dequeue
• enqueue déplace arriere vers la droite comme si
elle remplissait les emplacements du tableau
• Enqueue revient au début en exécutant
• dequeue déplace avant vers la droite comme si elle arriere = (arriere + 1) % QSIZE;
vidait les emplacements du tableau
• Lorsque enqueue arrive à la fin elle retourne vers le • Dequeue revient au début en exécutant
debut pour utiliser les emplacements qui ont été vdés avant = (avant + 1) % QSIZE;
• Lorsque dequeue arrive à la fin elle retourne vers le

debut pour utiliser les emplacemeents qui ont été
remplis
Copyright
Copyright©©2014,
desPublishing
Copyright©©2014,
desPublishing
9

Introduction à la TAD file (queue) Les files dynamiques
Gestion des exceptions dans une file statique
• Comme une pile, une file peut être implémentée en
• Comme présentée, la classe file statique peut rencontrer utilisant une liste chaînée
une erreur si l’on tente d’enfiler (enqueue) un élément dans
une file pleine et defiler (dequeue) une élément d’une file
vide • Ceci permet un redimensionnement dynamique et éviter
les problèmes de gestion des indices rencontrés avec les
files circulaires
• Une bonne conception est de lancer une exception
underflow ou une exception overflow et pemettre au
programmeur de determiner la manière de traiter l’exception NULL
• On rappelle qu’une exception est lancée dans un bloc try

et faire suivre ce bloc par un bloc catch pour traiter avant arriere
l’exception
Copyright
Copyright©©2014,
desPublishing
Copyright©©2014,
desPublishing

Les files dynamiques Les files dynamiques
Structures de données pour une file dynamique La fonction membre isEmpty
Pour vérifier si la file est vide:
• Définir une classe de file dynamique
bool isEmpty()
• Dans la file dynamique définir un noeud dynamique de {
la file en tant un membre privé de classe file
if (avant == NULL)
return true;
• Définir des pointeurs vers l’avant et vers l’arrière de la else
file
return false;
}
Copyright
Copyright©©2014,
desPublishing
Copyright©©2014,
desPublishing
10

Les files dynamiques Les files dynamiques
La fonction membre enqueue La fonction membre dequeue
Pour ajouter un élément à l’arrière de la file: Pour retirer un élément de l’avant de la file:
if (isEmpty()) if (isEmpty())
{ {
avant= new noeudF(x); error(); exit(1);
arriere= avant; }
} x = avant->valeur;
else noeudF *ancAvant = avant;
{ avant = avant->suivant;
arriere->suivant = new noeudF (x); delete ancAvant;
arriere = arriere->suivant;
}
Copyright
Copyright©©2014,
desPublishing
Copyright©©2014,
desPublishing

Les STL containers deque et queue Les STL containers deque et queue
Défnition d’une file
• deque: une file à deux bouts (double-ended queue DEC). • Définition d’une file de char, nommée cQueue, basée sur
A des fonctions membres pour enfiler (push_back) et un deque:
pour défiler (pop_front) deque<char> cQueue;
• queue: TAD de container qui peut être utilisé pour fournir • Définition d’une queue avec le container de base par défaut
une file basée sur vector, list, ou deque. A les queue<char> cQueue;
fonctions membres pour enfiler (push) et pour défiler
(pop)
• Définition d’une file basée sur une list:
queue<char, list<char> > cQueue;
• Des espaces sont nécessaires entre les symboles > >

consécutifs pour faire la distinction avec les streams
Copyright
Copyright©©2014,
desPublishing
Copyright©©2014,
desPublishing
11
Piles et Files (Queues)

Elimination de la récursivité
• Les solutions récursives sont souvent élégantes mais

inéfficaces
• Une solution qui n’utilise pas de récursivité est

beaucoup plus efficace pour les problèmes avec un
grand nombre d’entrées
• Elimination de la récursivité: re-écrire un algoritme

récursif de sorte qu’il utilise d’autres constructions en
programmation (piles, boucles) à la place des appels
récusrifs
Copyright
Copyright©©2014,
desPublishing
12

Chapitre 18 - Piles Et Files

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

Chapitre 18 - Piles Et Files

Transféré par

Droits d'auteur :

Formats disponibles

Programmation C++ 31/10/2017

Piles et Files (Queues)

Piles et Files (Queues) Piles et Files (Queues)

• Exemples: • Le bout actif d’une liste implémantant une pile est le

– Dynamique – taille variable, souvent implémentée à l’aide d’une liste

Piles et Files (Queues) Piles et Files (Queues)

Piles et Files (Queues) Piles et Files (Queues)

sommet est 1 sommet est 2 sommet est 3

Piles et Files (Queues) Piles et Files (Queues)

char p[TAILLE_PILE]; char p[TAILLE_PILE];

bool isEmpty() bool isFull()

Piles et Files (Queues) Piles et Files (Queues)

void push(char x) void pop(char &x)

Piles et Files (Queues) Piles et Files (Queues)

Piles et Files (Queues) Piles et Files (Queues)

Piles et Files (Queues) Piles et Files (Queues)

Piles et Files (Queues) Piles et Files (Queues)

void push(char x) void pop(char &x)

Piles et Files (Queues) Piles et Files (Queues)

• Il implémente d’autres fonctions membres: • Il implémente d’autres fonctions membres:

Piles et Files (Queues) Piles et Files (Queues)

• Implementée à l’aide d’une file deque (par défaut):

Piles et Files (Queues) Piles et Files (Queues)

• front (avant): emplacement à partir duquel les éléments

• enqueue (enfliler): ajouter un élément en arrière de la file enqueue('E');

• dequeue (defiler): retirer un élément à partir de l’avant E

Piles et Files (Queues) Piles et Files (Queues)

enqueue('K'); dequeue(); // retirer E

avant arrière avant arrière

Piles et Files (Queues) Piles et Files (Queues)

• D’autres conventions sont possible

Piles et Files (Queues) Piles et Files (Queues)

Vérifier si la file est vide Vérifier si la file est pleine

bool isEmpty() bool isFull()

Piles et Files (Queues) Piles et Files (Queues)

Piles et Files (Queues) Piles et Files (Queues)

• Lorsque dequeue arrive à la fin elle retourne vers le

Piles et Files (Queues) Piles et Files (Queues)

• On rappelle qu’une exception est lancée dans un bloc try

Piles et Files (Queues) Piles et Files (Queues)

Piles et Files (Queues) Piles et Files (Queues)

Piles et Files (Queues) Piles et Files (Queues)

• Des espaces sont nécessaires entre les symboles > >

Piles et Files (Queues)

• Les solutions récursives sont souvent élégantes mais

• Une solution qui n’utilise pas de récursivité est

• Elimination de la récursivité: re-écrire un algoritme

Vous aimerez peut-être aussi