Les piles en langage C
Piles en langage C Cette page vise à expliquer les piles en langage C, en abordant leur définition, les opérations que l'on peut effectuer sur elles, ainsi qu'un exemple complet de code. Vous apprendrez à initialiser une pile, à y insérer et à en retirer des éléments, tout en comprenant le fonctionnement interne de cette structure de données.
D'après le document Les piles en langage C
Cet article a été rédigé automatiquement à partir du document source, puis vérifié avant publication.
Document source
Computer Science · PDF · 10 pages · 2014
Afficher l'aperçu du document
Piles en langage C
Cette page vise à expliquer les piles en langage C, en abordant leur définition, les opérations que l'on peut effectuer sur elles, ainsi qu'un exemple complet de code. Vous apprendrez à initialiser une pile, à y insérer et à en retirer des éléments, tout en comprenant le fonctionnement interne de cette structure de données.
Définition des piles
La pile est une structure de données qui permet de stocker les données dans l'ordre LIFO (Last In First Out), c'est-à-dire que le dernier élément inséré est le premier à être retiré. Pour l'implémentation, une liste simplement chaînée est utilisée, où l'insertion se fait toujours au début de la liste. Ainsi, le premier élément de la liste est le dernier élément saisi, ce qui le place en haut de la pile.
Opérations sur les piles
Initialisation
Avant d'effectuer toute opération sur la pile, il est nécessaire de l'initialiser. Cela se fait en définissant le pointeur debut à NULL et la taille à 0.
void initialisation (Pile *tas) {
tas->debut = NULL;
tas->taille = 0;
}
Insertion d'un élément dans la pile
Pour insérer un élément dans la pile, on suit un algorithme qui consiste à déclarer l'élément à insérer, allouer de la mémoire pour le nouvel élément, remplir le champ de données, mettre à jour le pointeur debut et enfin mettre à jour la taille de 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++;
}
Ôter un élément de la pile
Pour retirer un élément de la pile, on doit supprimer l'élément pointé par debut. Cela ne permet pas de récupérer la donnée, mais seulement de la supprimer. La fonction renvoie -1 en cas d'échec, sinon elle renvoie 0.
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
Pour afficher la pile, on commence par se positionner au début de celle-ci. Ensuite, en utilisant le pointeur suivant de chaque élément, on parcourt la pile du premier au dernier élément. La fonction d'affichage est la suivante :
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;
}
}
Récupération de la donnée en haut de la pile
Pour récupérer la donnée en haut de la pile sans la supprimer, on utilise une macro qui permet de lire les données en utilisant le pointeur debut.
#define pile_donnee(tas) tas->debut->donnee
Exemple complet de code
Voici un exemple complet de l'utilisation des piles en langage C, incluant la définition des structures, les prototypes de fonctions, et le programme principal.
#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 éléments): \n", tas->taille);
affiche(tas);
// Répéter pour d'autres mots
return 0;
}
Points clés à retenir
Voici les éléments essentiels à retenir concernant les piles en langage C :
- Les piles fonctionnent selon le principe LIFO.
- Les opérations principales incluent l'initialisation, l'insertion, l'otage et l'affichage.
- Les éléments sont gérés à l'aide de structures et de pointeurs.
- La mémoire doit être correctement allouée et libérée pour éviter les fuites.
Questions fréquentes
Qu'est-ce qu'une pile en langage C ?
Une pile est une structure de données qui stocke les éléments selon le principe LIFO, permettant d'insérer et de retirer des éléments de manière ordonnée.
Comment initialiser une pile en C ?
Pour initialiser une pile, il faut définir le pointeur debut à NULL et la taille à 0, en utilisant la fonction initialisation.
Quelle est la différence entre une pile et une liste chaînée ?
La principale différence réside dans l'accès aux éléments : une pile permet d'accéder uniquement au dernier élément inséré, tandis qu'une liste chaînée permet d'accéder à tous les éléments de manière séquentielle.
Comment afficher les éléments d'une pile ?
Pour afficher les éléments d'une pile, on parcourt la structure en utilisant le pointeur suivant de chaque élément, en commençant par le premier élément.
Comment retirer un élément d'une pile ?
Pour retirer un élément, on déplace le pointeur debut vers le suivant et on libère la mémoire de l'élément supprimé.
Commentaires
Aucun commentaire pour le moment. Posez la première question.