Sofia Douda 1

LES PILES

Une pile est une liste linéaire dont seule une extrémité (appelée sommet) est accessible
(visible).
Opérations :

Les éléments sont extraits d’une pile dans l’ordre inverse de leur insertion. Ils suivent la loi
LIFO (Last In First Out).

Pile vide → Sommet = -1;

Insertion → Sommet = Sommet + 1 ;
Extraction → Sommet = Sommet – 1 ;

Organisation interne d’une pile

Nous construisons les fonctions suivantes :

Initialiser qui construit la pile vide P.
Empiler qui ajoute l’élément x à la pile si la pile n’est pas pleine.
Dépiler qui extrait le sommet x de la pile P si la pile n’est pas vide.
Pile_pleine qui retourne 1 si la pile est pleine et 0 sinon.
Pile _vide qui retourne 1 si la pile est vide et 0 sinon.

Nous appellerons element le type des éléments de la pile et sommet l’indice ou l’adresse
indiquant le sommet de la pile.

Représentation d’une pile par un tableau

Nous définissons un type prédéfini PILE comme une structure à deux champs : un tableau où
sont rangés les éléments insérés et une variable sommet dont la valeur est l’indice du sommet
de la pile. Nous avons les déclarations et les fonctions suivantes :

#define maxp 100 // Taille maximale que peut supporter la pile

typedef char element;
typedef struct
{ element T[maxp];
int sommet;
}PILE ;

LST GI : Cours sur les piles en C Année 2010/2011

Sofia Douda 2

void initialiser (PILE &P)

{
P.sommet= -1 ;
}

int pile_vide(PILE P) int pile_pleine(PILE P)

{ {
if (P.sommet== -1) return(1); if (P.sommet>=maxp-1) return(1);
return(0); return(0);
} }

void depiler(PILE &P, element & x)

void empiler(PILE &P, element x) {
{ if (sommet= = -1) printf(″Pile vide\n″) ;
if ( P.sommet= =maxp-1) printf(″Pile pleine \n″) ; else
else {
{ x=P.T[P.sommet] ;
P.sommet+=1 ; // P.sommet=P.sommet+1 ; P.sommet-=1 ; // P.sommet=P.sommet-1 ;
P.T[P.sommet]=x ; }
} }
}

Représentation d’une pile par une liste chaînée

On va utiliser une liste chaînée dont le premier nœud contiendra le dernier élément inséré de
sorte que le traitement de la pile consistera uniquement en insertion et suppression en tête de
liste. On peut appeler sommet cette tête de liste.

Dés qu’on impose à une liste les ajouts et les suppressions en tête de liste, cette liste devient la
représentation d’une pile.
Nous avons les déclarations et les fonctions suivantes :

LST GI : Cours sur les piles en C Année 2010/2011

Sofia Douda 3

#define char element

typedef struct nœud *pliste ;
typedef struct {
element elem;
pliste suivant;
} nœud ;
Typedef pile pliste ;

void initialser(pile P)
{
P=NULL ; // ou P=0 ;
}

void empiler(pile &P, element x) void depiler(pile &P, element &x, int vide)
{ {
pliste q ; if (P==0) printf(″pile vide\n″) ;
else
q=(pliste)malloc(sizeof(nœud)) ; {
if (q==0) printf(“pas d’espace mémoire”); x=P->elem;
else P=P->suivant;
{ }
q->elem=x ; }
q->suivant= P;
P=q;
}
}

Exemple d’utilisation de la pile

Le programme suivant permet de calculer l’inverse d’une chaine de caractères en utilisant la
pile.

#include <stdio.h>
#include <string.h>
#include <conio.h>

#define maxp 80 // Taille maximale que peut supporter la pile

typedef char element; /* on va manipuler des caratères dans la pile */

typedef struct
{ element T[maxp];
int sommet;
}PILE ;

PILE P;

LST GI : Cours sur les piles en C Année 2010/2011

Sofia Douda 4

/* Fonction qui initialise la pile */

void initialiser (PILE &P)
{
P.sommet=-1;
}
/*Fonction qui insère l'élément x dans la pile P */
void empiler(PILE &P, element x)
{
if (P.sommet==maxp-1) printf(″Pile pleine\n″) ;
else
{ P.sommet+=1 ; // P.sommet=P.sommet+1 ;
P.T[P.sommet]=x ;
}
}
/* Fonction qui extrait un élément de la pile P et le range dans x
*/
void depiler(PILE &P, element & x)
{
if (P.sommet==-1) printf(″Pile vide\n″) ;
else
{
x=P.T[P.sommet] ;
P.sommet-=1 ; // P.sommet=P.sommet-1 ;
}
}
/* Fonction qui calcule l'inverse d'une chaine ch et range
le résultat dans une deuxième chaine inv */
void inverse(char ch[20],char inv[20])
{
int i;
int L=strlen(ch);
for(i=0;(i<L)&&!pile_pleine(P);i++)
empiler(P,ch[i]);
if (i>=L)
{
i=0;
while(!pile_vide(P))
{
depiler(P,inv[i]);
i++;
}
inv[i]='\0';
}
else printf("Pile pleine\n");
}

int main()
{
char chaine[80];
char chaineinv[80];

printf("Donner une chaine\n");

gets(chaine);
initialiser(P);
inverse(chaine,chaineinv);
printf("\n\nLa chaine inverse de \"%s\" est \"%s\"\n",chaine,chaineinv);
getch(); return(0) ;
}

LST GI : Cours sur les piles en C Année 2010/2011