Aller au contenu

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

Les piles en langage C

Computer Science · PDF · 10 pages · 2014

Afficher l'aperçu du document

Consulter le document original →

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é.

Partager

Commentaires

Aucun commentaire pour le moment. Posez la première question.

Les commentaires sont relus avant publication. Votre e-mail n'est jamais affiché.

← Toutes les révisions