Vous êtes sur la page 1sur 26

PILES

RÉVISION
• Il existe deux modes de transmission des paramètres:
• Par valeur: le paramètre transmis n'est jamais affecté par les modifications
dans la procédure ou la fonction (on ne récupère pas les résultats !)

• Par adresse (référence) : le paramètre transmis dans ce cas peut être


modifié et on récupère les résultats.
LES FONCTIONS ET LES DIFFÉRENTES
MÉTHODES DE PASSAGE DE VARIABLES
• void passvaleur(int d) {d++ ;} //prend 1 valeur
void passadresse(int *d) {(*d)++ ;}//prend 1 adresse

• void main()
{ int a=2,b=2;
passvaleur(a) ; //a=2 l’adresse n’étant pas connue
passadresse(&b) ; //b=3 passage de l’adresse de b
}
LES PILES RÉVISION

• une pile (en anglais stack)


• une structure de
données fondée sur le
principe « dernier arrivé,
premier sorti » (en
anglais LIFO pour last in,
first out), ce qui veut dire,
qu'en général, le dernier
élément, ajouté à la pile,
sera le premier à en sortir.
APPLICATIONS
• Les algorithmes récursifs utilisent une pile d'appel.
• Dans un navigateur web, une pile sert à mémoriser les pages Web visitées.
L'adresse de chaque nouvelle page visitée est empilée et l'utilisateur dépile
l'adresse courante pour accéder à la page précédente en cliquant le
bouton « Afficher la page précédente ».
• L'évaluation des expressions mathématiques en notation post-fixée utilise
une pile.
• La fonction « Annuler la frappe » (en anglais Undo) d'un traitement de texte
mémorise les modifications apportées au texte dans une pile.
LES FONCTIONS DE BASE
• Voici les primitives communément
utilisées pour manipuler des piles:
• « Empiler » : ajoute un élément sur la
pile. Le terme anglais correspondant
est push.
• « Dépiler » : enlève un élément de la
pile et le renvoie. Le terme anglais
correspondant est pop.
• « La pile est-elle vide ? » : renvoie
vrai si la pile est vide, faux sinon.
DÉCLARATION DES BIBLIOTHÈQUES

#include<stdio.h>
#include <stdlib.h>
DÉCLARATION D’UNE STRUCTURE DE PILES

Déclaration
typedef struct element d’une structure
{ de piles

char valeur;
Une valeur de type char
struct element *suivant;
} element; Un pointeur vers une variable
de type element
FONCTION AFFICHER
Une fonction qui permet d’afficher
//fonction affichage de la pile les éléments d’une pile
void afficher (element *tete) Elle ne retourne rien

{ element *adr_actuel=tete; Déclaration d’une variable locale


while (adr_actuel != NULL) qui permet de copier l’adresse de la
tête de la pile
{ printf ("\n%c", (*adr_actuel).valeur);
adr_actuel = (*adr_actuel).suivant; Tant que la variable n’est pas vide

}
Afficher la valeur contenu dans
} l’adresse (adr_actuel)

Se pointer vers l’élément suivant de


la pile,
FONCTION D’INSERTION D’UN
ELEMENT
element *empiler (element *tete, char val)
{ element *x=malloc(sizeof(element)); Empiler: fonction qui insère
(*x).valeur = val; l‘élément x, dans la pile
(*x).suivant = NULL;
if (tete == NULL) « * tete » qui est le pointeur vers la
{ tête de la pile concerner
tete = x; // l'element insC)rC) devient la tete de la pile « Val » qui représente l’élément a
} insère
else
{
(*x).suivant = tete; // l'element insC)rC) devient la tete de la pile
tete = x;
}
return tete;
}
FONCTION D’INSERTION D’UN
ELEMENT
element *empiler (element *tete, char val)
{ element *x=malloc(sizeof(element)); Création de un espace mémoire pour le
nouveau élément
(*x).valeur = val;
(*x).suivant = NULL;
if (tete == NULL) Remplissage du nouveau élément
{
tete = x; Le cas du premier élément de la pile
} - Il est insérer en tête de liste
else - aucun élément suivant
{
(*x).suivant = tete; Le cas des autres éléments de la pile
tete = x; -- Il est insérer en tête de liste
} - l’ancien tête deviens l’élément suivant du
return tete; nouveau élément de la tête de la liste
}
FONCTION D’ELIMINATION D’UN
ELEMENT
element * depiler(element *tete, char *val) depiler: fonction qui supprime
{ element *x=tete; l‘élément x de la tête de liste.

if (x != NULL) Elle retourne l ’adresse de la


{ nouvelle tête et la valeur suprimer
dans val
*val= (*x).valeur;
tete=(*x).suivant; Si la pile n’est pas vide
} Récupérer le valeur supprimer dans « val »
Modifier le pointeur de la tête de liste et le
free(x); retourner dans « tete »
return tete;
}
Libérer l’espace mémoire
• void main(){
element *tete_pile=NULL; CODE MAIN
tete_pile = empiler (tete_pile, 'a');
afficher (tete_pile);
printf ("\n----\n");
tete_pile = empiler (tete_pile, 'b');
afficher (tete_pile);
printf ("\n----\n");
tete_pile = empiler (tete_pile, 'c');
afficher (tete_pile);
printf ("\n----\n");
printf ("\n----\n");
char v;
tete_pile=depiler(tete_pile, &v);
printf("\n%c",v);
printf ("\n----\n");
afficher (tete_pile);
printf ("\n----\n");
}
EXERCICES
EXERCICE N°1: LAST VALUE

Créer une fonction pile_last retournant la valeur du dernier élément, mais sans
le dépiler.

Vous aimerez peut-être aussi