LES PILES

INTRODUCTION

➢Une pile (stack en anglais) est une liste dans laquelle l’insertion ou
la suppression se fait toujours à partir de la même extrémité appelée
sommet de la pile.

➢Une pile permet de modéliser un ensemble régi par la discipline

‘dernier arrivé premier sorti’

LIFO : Last In First Out
1
 LES PILES

CARACTERISTIQUES GENERALES

➢Ensemble de données dans lequel on a la possibilité de demander :

* ensemble vide ?
* éventuellement ensemble plein ?

➢On peut faire dans cet ensemble :

* Ajouter un élément (empiler)
* Retirer le 1er élément (dépiler)
* Donner l’élément qui se trouve au sommet
* Eventuellement, vider la pile

2
 Fct A

LES PILES Fct B

Fct C

UTILISATION

Exemples: Seules actions possibles :

➢Pile courante L’Ajout d’un élément au sommet
➢ Pile informatique Le Retrait d’un élément au sommet

Opérations effectuées sur les piles :

vider(p) : vide le contenu de la pile P
Premier(P) : retourne (sans le dépiler) l’élément au sommet de P
Dépiler(P) : supprime physiquement l’élément au sommet de P
Empiler(x,P) : insère l’élément x au sommet de P
Pile-vide(P) : fonction qui teste si P est vide
Pile_pleine(P): teste si la pile P est pleine ou non
3
 LES PILES

IMPLEMENTATIONS
Implémentation dynamique par une liste chaînée
Une pile en dynamique n'a pas de taille limite, hormis celle de la mémoire
centrale (RAM) disponible.

Implémentation statique sous forme de tableau

4
 pointp
LES PILES

Implémentation sous forme de tableau

max-1
#define max …
struct pile{typelt tab[max] ;
int pointp;}; // pointeur de pile indice du sommet de la pile max-1
Typedef struct pile * ppile;
max-2

int vide(ppile p) int pile_pleine(ppile p)

{return(p->pointp == -1);} {return(p->pointp == max-1);} pointp+1
x
void empiler(typelt x,ppile p) { pointp a
if(p->pointp<max-1) { p->tab[p->pointp+1]=x; p->pointp= p->pointp+1;}
}
void depiler(ppile p) {
if(!vide(p)) p->pointp= p->pointp-1;}

typelt premier(ppile p) { return (p->tab[p->pointp]) ;} 0

5
 LES PILES

Implémentation sous forme de tableaux

#define Max .... max-1

int pile[Max];
int pointp=0; //indice où je vais insérer le prochain élément

void vider()
{pointp=0;}
pointp
int pile_pleine()
{return(pointp==Max);} x

int pile_vide()
{return(pointp==0);}

6
 LES PILES

Implémentation sous forme de tableaux

int premier_pile()
max-1
{ return(pile[pointp-1]);}

Int/void depiler()
{pointp--;
return(pile[pointp]);
} pointp

void empiler(int x) x
{pile[pointp]=x;
pointp++;
}

7
 LES PILES

Implémentation sous forme de tableaux

int main()
{ int i,n,valeur;
do{
printf("saisir un entier : ");
scanf("%d",&n);}while(n<1);
printf("\nRemplissage de la pile\n");
for(i=0;i<n;i++)
{ printf("saisir une valeur dans la pile :");scanf("%d",&valeur);
if (!pile_pleine()) empiler(valeur);
}
printf("\n Vider la pile\n");
while(!pile_vide()) {printf("VALEUR = %d\n",depiler());}
printf("\n");
return 0;
}

8
 LES PILES

Implémentation sous forme liste chaînée

struct element { int val;
struct element *suiv;} ;
typedef struct element *pile;

void empiler(int x,pile *p)

{
pile nouveau;
nouveau=(pile)malloc(sizeof(struct element));
nouveau->val=x;
nouveau->suiv=*p;
*p=nouveau;
}

int pilevide(pile p)
{return(p==NULL);}

9
 LES PILES

Implémentation sous forme liste chaînée

int premier_pile(pile p)
{ return(p->val);}

int depiler(pile *p)

{int sommet;
pile q;
q=*p;
sommet = (*p)->val;
*p = (*p)->suiv; free(q);
return(sommet);
}

10
 LES PILES

Implémentation sous forme liste chaînée

int main()
{int i,n,valeur;pile p=NULL;
do{ printf("\nsaisir un entier : ");
scanf("%d",&n);}while(n<1);

printf("\nRemplissage de la pile\n\n");
for(i=0;i<n;i++)
{ printf("saisir une valeur dans la pile :");scanf("%d",&valeur);
empiler(valeur,&p);
}
printf("\n Vider la pile\n\n");
while(!pile_vide(p)) {printf("VALEUR = %d\n",depiler(&p));}
printf("\n");
return 0;
}

11
 LES FILES

REPRESENTATION INTUITIVE

➢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 parti » : ce qui justifie le terme anglo-saxon
« FIFO List »

12
 LES FILES

OPERATIONS SUR LES FILES

Exemples :
➢Gestion d’accès à une ressource informatique : en système les files sont utilisées
pour gérer tous les processus en attente de ressource système
➢D'une façon générale, la notion de file intervient dans un modèle dès qu'il est
question d'une file d'attente : systèmes de réservation, gestion de pistes d'aéroport
……etc.
Opérations :
Tete(F) : retourne l’élément en tête de F
Queue(F) : retourne l’élément en fin de F
Enfiler(x,F) : insère l’élément x à la fin de la file F
Defiler(F) : supprime le premier élément de la file F
13
 LES FILES

MISE EN ŒUVRE DES FILES PAR POINTEURS

➢ Une file est une liste dont on conserve en permanence le premier élément qui
représente la tête de la file et le dernier élément qui représente la queue de la file.
➢ Elle est définie par deux pointeurs :
dernier : pointeur sur la queue pour enfiler les éléments
premier : pointeur sur la tête pour défiler les éléments
➢ A part cette spécificité c'est un cas normal de liste chainée
➢En dynamique une file n'a pas de taille limite, hormis celle de la mémoire centrale
(RAM) disponible.

14
 LES FILES

MISE EN ŒUVRE DES FILES PAR POINTEURS

struct elem{ typelt val ; int filevide(pfile f )

struct elem *suiv;}; void enfiler(pfile f , pelem x)
Typedef struct elem * pelem; pelem liretete(pfile f)
pelem lirequeue (pfile f)
Val
struct file{ pelem defiler(pfile f)
pelem premier; // sortie
pelem dernier; // entrée
};

Typedef struct file * pfile;

tete Queue
premier Dernier
int filevide(pfile f)
{return f->dernier==NULL;} 1
15
 LES FILES
1
IMPLEMENTATION PAR POINTEURS

➢Enfiler un nouvel élément consiste à effectuer les opérations suivantes :

le suivant du dernier devient le nouveau
le dernier devient le nouveau.
➢Si la file est vide alors premier et dernier prennent la valeur du nouvel élément
void enfiler(pfile f, pelem x)
{ 1
if (filevide(f)) {f->dernier=x;
f->premier=x;} a
else { f->dernier->suiv=x;
f->dernier=x;} x

}
pelem creer(int a) {
x =(pelem)malloc(sizeof(struct elem)) ;
x ->val=a ;
x->suiv=NULL;
return x;} 16
 LES FILES

IMPLEMENTATION PAR POINTEURS

pelem liretete(pfile f) pelem lirequeue(pfile f)

{ {
pelem q=NULL; pelem q=NULL;
if (!filevide(f)) if (!filevide(f))
q=f->premier; q=f->dernier;
return q; return q;
} }

premier
1
dernier

17
 LES FILES

IMPLEMENTATION PAR POINTEURS

Défiler : consiste à retourner l'adresse de l’élément sortant et passer la tête

au suivant. premier 1

Deux cas sont à envisager : dernier

▪file avec un seul élément : on retourne son adresse et on met premier et

dernier à NULL.
•file avec plusieurs éléments : on retourne l'adresse du premier et le premier
prend l'adresse du suivant premier
1
dernier

a
18
 LES FILES

IMPLEMENTATION PAR POINTEURS

Défiler : consiste à retourner l'adresse

pelem defiler(pfile f)
de l’élément sortant et passer la tête { pelem q=NULL;
if(!filevide(f)){
au suivant.
// si file non vide retirer en tête
Deux cas sont à envisager : if (f->premier==f->dernier){
// si un seul élément
▪file avec un seul élément : on retourne
q=f->premier;
son adresse et on met premier et f->premier=NULL;
f->dernier=NULL;
dernier à NULL.
}
•file avec plusieurs éléments : on else{ // si plusieurs
q=f->premier;
retourne l'adresse du premier et le
f->premier=(f->premier)->suiv;}
premier prend l'adresse du suivant }
return q;
} 19
 LES FILES

IMPLEMENTATION PAR UN TABLEAU

➢ premier : indice pour la tête de la file

➢ dernier : indice pour la queue de la file
➢ un tableau d’éléments de taille Nbmax tête queue

➢ Déclaration : #define Nbmax ….

struct file { int premier,dernier;
typelt Tab[Nbmax];
}
typedef struct file *pfile;

➢Les données se trouvent entre ‘premier’ et ‘dernier’

20
 LES FILES
IMPLEMENTATION PAR UN TABLEAU (TABLEAU SIMPLE)
Tete Queue Tete Queue

(
(5)

( (
(6) (7)

on ne peut plus ajouter d’éléments dans la file alors qu’elle n’est pas pleine 21
 LES FILES
IMPLEMENTATION PAR TABLEAU (TABLEAU SIMPLE AVEC DECALAGE)

20

(
(5)

( (
(6) (7)

On doit décaler les éléments de la file après chaque suppression

d’où un décalage très coûteux si la file contient beaucoup d’éléments
22
 LES FILES

IMPLEMENTATION PAR UN TABLEAU (TABLEAU CIRCULAIRE)

Gestion du tableau de manière cyclique

➢ les nouveaux éléments entrants peuvent être placés au début ou à la fin

selon la place restante dans le tableau

➢ les indices de la tête et de la queue progressent maintenant modulo la taille

du tableau.

23
 LES FILES

IMPLEMENTATION PAR UN TABLEAU

➢la file est pleine lorsque la tête et la queue coïncident ce qui représente la
même condition quand la file est vide : il est clair que cette situation n’est pas
satisfaisante.

➢une solution consiste à laisser au moins l’espace d’un élément entre la tête et la
queue : si la taille de la file est de 100 par exemple, il faudra réserver un tableau à
101 éléments.

➢Le champ dernier (par exemple) correspond à la position libre suivante pour le
prochain arrivant

➢la file est pleine si le dernier élément retrouve le premier dans le tableau
circulaire après un tour complet en partant de n'importe quelle position

24
 LES FILES

IMPLEMENTATION PAR UN TABLEAU

int file_vide(pfile f) typelt defiler(pfile f)

int file_pleine(pfile f) void enfiler(pfile f , typelt e)

int file_vide(pfile f)
{
return f->dernier==f->premier;
}

int file_pleine(pfile f)
{
return ((f->dernier+1)%Nbmax == f->premier) ;
}

25
 LES FILES

IMPLEMENTATION PAR UN TABLEAU

void enfiler(pfile f,typelt x)

{ if (!file_pleine(f)){
f->tab[f->dernier]=x;
f->dernier =(f->dernier+1)%Nbmax;
}
}

typelt defiler(pfile f)
{
typelt x;
x=f->tab[f->premier];
f->premier=(f->premier+1)%Nbmax;
return x;
}

26
 LES ARBRES

GENERALITES

Les listes sont des structures dynamiques unidimensionnelles. Les

arbres sont leur généralisation multidimensionnelle. Comme pour le

premier d’une liste, l’adresse de la racine est nécessaire et suffisante

pour accéder à l’intégralité d’un arbre.

27
 LES ARBRES
N

DEFINITION N1 Nk

A1 Ak

Un arbre peut se définir de manière récursive :

➢un sommet unique, par lui même, est un arbre. Dans ce cas, il est aussi
la racine de l’arbre
➢si n est un sommet et A1, A2, … , Ak sont des arbres de racines
respectives n1, n2, … , nk ; on peut construire un nouvel arbre en
associant comme parent unique aux sommets n1, n2, … , nk le sommet n.
Dans cet arbre, n est la racine et A1, A2, … , Ak sont les ss-arbres. Les
sommets n1, n2, … , nk sont appelés les fils de n.

28
 LES ARBRES

TERMINOLOGIE

➢On utilise un vocabulaire inspiré des arbres généalogiques.

➢Chaque composante d’un arbre contient une valeur, et des liens vers ses fils.
➢Chaque élément d’un arbre se nomme un nœud.
➢Le nœud racine est le seul qui n’est le fils d’aucun nœud.
➢Un nœud qui n’a pas de fils est un noeud externe ou feuille
➢Un nœud qui n’est pas une feuille est dit interne.

29
 LES ARBRES

TERMINOLOGIE

➢Chemin: suite unique de sommets

➢Longueur d’un chemin : nombre d’arcs intervenant dans ce chemin
➢La hauteur d’un noeud s : la longueur du plus long chemin issu de s
➢La profondeur d’un noeud s : longueur du chemin r s.
➢ La hauteur de l’arbre : la profondeur maximale de ses nœuds.
➢Etant donné un sommet u, tous les sommets, autres que lui même, situés
sur le chemin de la racine à u sont appelés des ancêtres, le dernier étant son
père.
➢Deux sommets qui ont le même père sont des frères

30
 LES ARBRES

TERMINOLOGIE

Arité d’un arbre

Un arbre dont les nœuds ne comportent
qu’au maximum n fils est un arbre d’arité n.
On parle alors d’un arbre n-aire. Un arbre
d’arité 2 est un arbre binaire. On parle alors 4-aire
de fils gauche et de fils droit. Taille=10

Taille d’un arbre :

La taille d’un arbre est le nombre de nœuds
qui le composent

31
 LES ARBRES
N
TERMINOLOGIE
N1 Nk

➢Notion d’ordre
A1 Ak

➢Tout sommet est la racine d’un arbre formé par sa descendance et lui-même

récursivité de certains algorithmes sur les arbres

➢Les fils d’un sommet ne sont pas dans un ordre arbitraire et dans ce cas, on
parlera de fils aîné, cadet, etc .. l’ordre étant de gauche à droite dans une
représentation « standard »
➢ d +(s) « degré sortant » est le nombre de fils du sommet s
➢ d -(s) « degré entant » est le nombre de pères du sommet s
N.B: Ʃ d +(s) = Ʃ d- (s) = a = n-1
où a et le nombre d’arcs et n le nombre de sommets père

feuille 32
 ➢ d +(s) « degré sortant » est le nombre de fils du sommet s

➢ d -(s) « degré entant » est le nombre de pères du sommet s

N.B: Ʃ d +(s) = Ʃ d- (s) = a = n-1

où a et le nombre d’arcs et n le nombre de sommets

n=1 Taille=n

Ʃ d +(s) = Ʃ d +(s) + d+(feuille)

Taille = n+1
= n-1 +1 + 0 = n = (n+1)-1

Ʃ d -(s) = Ʃ d -(s) + d-(feuille)

père = n-1 + 1 = n = (n+1)-1

feuille

33
 LES ARBRES

arbre binaire

Possibilité de passer d’un arbre n-aire à un arbre binaire grâce aux primitives Premier
fils (PF) et Frère Droit (FD) ou Premier frère (FR)
3-aire
PF PF

FD ou FR FD ou FR

struct nœud {
typelt info ;
struct nœud *PF ;
struct nœud *FR ;} ;
typedef struct nœud *arbre ;
34
 LES ARBRES

PARCOURS D’ARBRES

Le parcours d’arbre est une opération qui consiste à retrouver systématiquement

tous les noeuds de cet arbre et d'y appliquer un même traitement

➢ Parcours en profondeur
Parcourir un arbre en profondeur consiste à visiter ses
nœuds en descendant le plus profondément possible dans
l’arbre.
Lorsque l’on arrive sur un arbre vide, on remonte jusqu’au
nœud supérieur et on redescend dans le fils encore
inexploré
➢ Parcours en largeur
On explore chaque noeud d'un niveau donné de gauche à
droite, puis on passe au niveau suivant.
35
 LES ARBRES

PARCOURS D’ARBRES

J K

Parcours en largeur : A B C D E F G H J K I
Parcours en profondeur : A B E F G B C D H J K I H D A

36
Exemple

Largeur : A B C D E F G H I

Profondeur : A B E F G B C H I C D A

37
 LES ARBRES

PARCOURS EN PROFONDEUR
Parcours en profondeur : A B E F G B C D H J K I H D A

Début
x racine
Repeter
Si x a un fils alors x Premier_fils(x) G
Sinon x A
Debut B J K
Tque x n’a pas de frère et x ≠ racine faire E
F
x père(x) G
Fintque B
C
Si x≠ racine alors x  Frère_droit (x) D
Fin H
Jusqu’à x=racine J
K
Fin I
H
D
N.B : tant que et non Si car ce dernier conduit à une boucle infinie ( ex : du côté duA H) 38