Dcouvrir le quadruple-play Accueil Fiches pratiques Programmation Langages Langage C Les piles en langage C Imprimer

Formations certifiantes Informatique et Management

Les piles en langage C

Publi par lami20j - Dernire mise jour le 17 novembre 2009 16:02 par marlalapocket

Les piles
Requis I. INTRODUCTION II. Dfinition III. La construction du prototype d'un lment de la pile IV. Oprations sur les piles A. Initialisation B. Insertion d'un lment dans la pile C. ter un lment de la pile D. Affichage de la pile E. Rcupration de la donne en haut de la pile V. Exemple complet pile.h pile_function.h pile.c VI. Voir aussi

Requis
2 of 14

Les types de donnes Les structures L'utilisation de typedef Les pointeurs Les fonctions utilisateur Les listes simplement chanes Les listes doublement chanes

I. INTRODUCTION
Cette article a pour but la comprhension des piles. L'implmentation en fonction du besoin vous appartient. Pour expliquer l'algorithme j'ai choisi d'utiliser une liste simplement chane. Donc la comprhension des listes chanes est ncessaire.

II. Dfinition
La pile est une structure de donnes, qui permet de stocker les donnes dans l'ordre LIFO (Last In First Out) - en franais Dernier Entr Premier Sorti). La rcupration des donnes sera faite dans l'ordre inverse de leur insertion. Pour l'implmentation j'ai choisi une liste simplement chane, prsente sur la verticale. L'insertion se faisant toujours au dbut de la liste, le 1er lment de la liste sera le dernier lment saisi, donc sa position est en haut de la pile. Je n'ai pas utilis un pointeur fin, comme je l'ai fait dans le cas des listes simplement chanes, puisque le but ce n'est pas de traiter une liste chane, mais la pile. Ce qui nous intresse c'est que le dernier lment entr, sera le 1er lment rcupr.

3 of 14

III. La construction du prototype d'un lment de la pile

Pour dfinir un lment de la pile le type struct sera utilis. L'lment de la pile contiendra un champ donnee et un pointeur suivant. Le pointeur suivant doit tre du mme type que l'lment, sinon il ne pourra pas pointer vers l'lment. Le pointeur suivant permettra l'accs vers le prochain lment.
typedef struct ElementListe { char *donnee; struct ElementListe *suivant; }Element;

Pour permettre les oprations sur la pile, nous allons sauvegarder certains lments : le premier lment le nombre d'lments

Le 1er lment, qui se trouve en haut de la pile, nous permettra de raliser l'opration de rcupration des donnes situes en haut de la pile. Pour raliser cela, une autre structure sera utilise (ce n'est pas obligatoire, des variables peuvent tre utilises). Voici sa composition :
typedef struct ListeRepere{ Element *debut; int taille; } Pile;

Le pointeur debut contiendra l'adresse du premier lment de la liste. La variable taille contient le nombre d'lments. Observation : Nous n'utilisons pas cette fois un pointeur fin (voir les listes simplement chanes), puisque nous n'en avons pas besoin, vu que nous travaillons qu'au dbut de la liste. Quelque soit la position dans la liste, le pointeur debut pointe toujours vers le 1er lment, qui sera en haut de la pile. Le champ taille contiendra le nombre d'lments de la pile, quelque soit l'opration effectue sur la pile.

IV. Oprations sur les piles

A. Initialisation

4 of 14

Prototype de la fonction :
void initialisation (Pile *tas);

Cette opration doit tre faite avant toute autre opration sur la pile. Elle initialise le pointeur debut avec le pointeur NULL, et la taille avec la valeur 0. La fonction
void initialisation (Pile * tas){ tas->debut = NULL; tas->taille = 0; }

B. Insertion d'un lment dans la pile

Voici l'algorithme d'insertion et de sauvegarde des lments : dclaration d'lment(s) insrer allocation de la mmoire pour le nouvel lment remplir le contenu du champ de donnes mettre jour le pointeur debut vers le 1er lment (le haut de la pile) mettre jour la taille de la pile

Prototype de la fonction :
int empiler (Pile *tas, char *donnee);

La 1re image montre le dbut de l'insertion, donc la liste a la taille 1 aprs l'insertion. La caractristique de la pile n'est pas trs bien mise en vidence avec un seul lment, puisque c'est le seul rcuprer.

5 of 14

En revanche la 2me image nous permet d'observer le comportement de la pile. La chose qu'il faut retenir, c'est que l'insertion se fait toujours en haut de la pile (au dbut de la liste).

La fonction
/* empiler (ajouter) un lment dans la pile */ int empiler (Pile * tas, char *donnee){ Element *nouveau_element; if ((nouveau_element = (Element *) malloc (sizeof (Element))) == NULL) return -1; if ((nouveau_element->donnee = (char *) malloc (50 * sizeof (char))) == NULL) return -1; strcpy (nouveau_element->donnee, donnee); nouveau_element->suivant = tas->debut; tas->debut = nouveau_element; tas->taille++; }

C. ter un lment de la pile

Pour supprimer (ter ou dpiler) l'lment de la pile, il faut tout simplement supprimer l'lment

6 of 14

vers lequel pointe le pointeur debut. Cette opration ne permet pas de rcuprer la donne en haut de la pile, mais seulement de la supprimer. Prototype de la fonction :
int depiler (Pile *tas);

La fonction renvoie -1 en cas d'chec sinon elle renvoie 0. Les tapes : le pointeur supp_elem contiendra l'adresse du 1er lment le pointeur debut pointera vers le 2me lment (aprs la suppression du 1er lment, le 2me sera en haut de la pile) la taille de la pile sera dcrmente d'un lment

La fonction
int depiler (Pile * tas){ Element *supp_element; if (tas->taille == 0) return -1; supp_element = tas->debut; tas->debut = tas->debut->suivant; free (supp_element->donnee); free (supp_element); tas->taille--; return 0; }

D. Affichage de la pile
7 of 14

Pour afficher la pile entire, il faut se positionner au dbut de la pile (le pointeur debut le permettra). Ensuite, en utilisant le pointeur suivant de chaque lment, la pile est parcourue du 1er vers le dernier lment. La condition d'arrt est donne par la taille de la pile. La fonction
/* affichage de la pile */ void affiche (Pile * tas){ Element *courant; int i; courant = tas->debut; for(i=0;i<tas->taille;++i){ printf("\t\t%s\n", courant->donnee); courant = courant->suivant; }

E. Rcupration de la donne en haut de la pile

Pour rcuprer la donne en haut de la pile sans la supprimer, j'ai utilis une macro. La macro lit les donnes en haut de la pile en utilisant le pointeur debut.
#define pile_donnee(tas) tas->debut->donnee

V. Exemple complet
pile.h

/*********************\ * pile.h * \*********************/ typedef struct ElementListe{ char *donnee; struct ElementListe *suivant; } Element; typedef struct ListeRepere{ Element *debut; int taille; } Pile; /* initialisation */ void initialisation (Pile *tas);

8 of 14

/* EMPILER*/ int empiler (Pile *tas, char *donnee); /* DEPILER*/ int depiler (Pile *tas); /* Affichage de lment en haut de la pile (LastInFirstOut) */ #define pile_donnee(tas) tas->debut->donnee /* Affiche la pile */ void affiche (Pile *tas);

pile_function.h

/***********************\ * pile_function.h * \***********************/ void initialisation (Pile * tas){ tas->debut = NULL; tas->taille = 0; } /* empiler (ajouter) un lment dans la pile */ int empiler (Pile * tas, char *donnee){ Element *nouveau_element; if ((nouveau_element = (Element *) malloc (sizeof (Element))) == NULL) return -1; if ((nouveau_element->donnee = (char *) malloc (50 * sizeof (char))) == NULL) return -1; strcpy (nouveau_element->donnee, donnee); nouveau_element->suivant = tas->debut; tas->debut = nouveau_element; tas->taille++; } /* depiler (supprimer un lment de la pile */ int depiler (Pile * tas){ Element *supp_element; if (tas->taille == 0) return -1; supp_element = tas->debut; tas->debut = tas->debut->suivant; free (supp_element->donnee); free (supp_element); tas->taille--; return 0; } /* affichage de la pile */ void affiche (Pile * tas){ Element *courant; int i; courant = tas->debut; for(i=0;i<tas->taille;++i){ printf("\t\t%s\n", courant->donnee); courant = courant->suivant; }

9 of 14

pile.c

/*********************\ * pile.c * \*********************/ #include<stdio.h> #include<stdlib.h> #include<string.h> #include "pile.h" #include "pile_function.h" int main () { Pile *tas; char *nom; if ((tas = (Pile *) malloc (sizeof (Pile))) == NULL) return -1; if ((nom = (char *) malloc (50 * sizeof (char))) == NULL) return -1; initialisation (tas); printf ("Entrez un mot : "); scanf ("%s", nom); empiler (tas, nom); printf ("La pile (%d lments): \n",tas->taille); printf("\n********** Haut de la PILE **********\n"); affiche(tas); printf("__________ Bas de la PILE __________\n\n"); printf ("Entrez un mot : "); scanf ("%s", nom); empiler (tas, nom); printf ("La pile (%d lments): \n",tas->taille); printf("\n********** Haut de la PILE **********\n"); affiche(tas); printf("__________ Bas de la PILE __________\n\n"); printf ("Entrez un mot : "); scanf ("%s", nom); empiler (tas, nom); printf ("La pile (%d lments): \n",tas->taille); printf("\n********** Haut de la PILE **********\n"); affiche(tas); printf("__________ Bas de la PILE __________\n\n"); printf ("\nLe dernier entr (LastInFirstOut) [ %s ] sera supprim", pile_donnee(tas)); printf ("\nLe dernier entr est supprime\n"); depiler (tas); /* suppression de dernier element entre */ printf ("La pile (%d lments): \n",tas->taille); printf("\n********** Haut de la PILE **********\n"); affiche(tas); printf("__________ Bas de la PILE __________\n\n"); } return 0;

10 of 14