Pile

Parcourez pas à pas une pile C++ construite avec des nœuds.

Tout est simulé dans ce navigateur ; rien n'est envoyé à un serveur.

Valeurs

Créer le nouveau nœud

Créer le nouveau nœud

n_ = 0

La pile est vide

  • Vient d'être ajouté
  • Sort maintenant

Étape 1 / 47

Code

#include <iostream>
using namespace std;
class Nodo { // Un nœud contient la donnée et un pointeur vers le suivant
private: // Attributs privés : seules les méthodes y touchent
int dato;
Nodo* siguiente;
public:
Nodo(int d) : dato(d), siguiente(nullptr) {}
int getDato() const { return dato; }
Nodo* getSiguiente() const { return siguiente; }
void setDato(int d) { dato = d; }
void setSiguiente(Nodo* s) { siguiente = s; }
};
class Pila {
private: // Le dernier nœud empilé est le sommet
Nodo* cima_; // Nœud du sommet
int n_; // Nombre de nœuds
public:
Pila() : cima_(nullptr), n_(0) {}
// Destructor (no se anima)
~Pila() {
while (cima_ != nullptr) desapilar();
}
void apilar(int valor) { // Empiler au sommet : O(1)
Nodo* nuevo = new Nodo(valor); // Créer le nœud
nuevo->setSiguiente(cima_); // Le nouveau nœud pointe vers l'ancien sommet
cima_ = nuevo; // cima_ pointe maintenant vers le nouveau nœud
n_++;
}
void desapilar() { // Dépiler le sommet : O(1)
if (cima_ == nullptr) return; // Pile vide : rien à retirer
Nodo* temp = cima_; // Conserver le sommet pour pouvoir le libérer
cima_ = cima_->getSiguiente(); // cima_ descend au nœud suivant
delete temp; // Libérer la mémoire
n_--;
}
// Muestra la pila de la cima a la base
void imprimir() const {
cout << "cima ->";
for (Nodo* p = cima_; p != nullptr; p = p->getSiguiente())
cout << " " << p->getDato();
cout << endl;
}
};
int main() {
Pila pila;
pila.apilar(3);
pila.apilar(6);
pila.apilar(9);
pila.imprimir(); // cima -> 9 6 3
pila.desapilar();
pila.imprimir(); // cima -> 6 3
pila.apilar(1);
pila.imprimir(); // cima -> 1 6 3
return 0;
}

Ce visualiseur de pile montre le fonctionnement d'une structure LIFO, où le dernier élément empilé est le premier dépilé. La pile est construite avec des nœuds C++ et un pointeur appelé cima_ qui désigne le nœud du sommet. Vous pouvez générer une séquence aléatoire ou ajouter vos propres opérations push et pop, jusqu'à 12 au total. À la lecture, vous voyez le nœud créé, relié à l'ancien sommet, le déplacement de cima_ et la libération de la mémoire, tandis que la ligne de code correspondante est surlignée. Dépiler une pile vide est clairement signalé. Tout s'exécute dans votre navigateur et rien n'est envoyé.

Comment l'utiliser

  1. Choisissez la taille et appuyez sur Mélanger pour générer une séquence d'opérations aléatoire, ou démarrez avec une liste vide.
  2. Sélectionnez Push ou Pop, saisissez la valeur pour un push et appuyez sur Ajouter pour ajouter l'opération.
  3. Appuyez sur Lecture ou avancez avec les boutons d'étape précédente et suivante.
  4. Observez le compteur n_, le pointeur cima_ et la case marquée comme ajoutée ou sortante.

Questions fréquentes

Que signifie LIFO ?
Last In, First Out : le dernier élément empilé est le premier à sortir, on ne travaille donc toujours qu'avec le sommet de la pile.
Quelles opérations propose-t-il ?
Push pour ajouter une valeur et Pop pour retirer le sommet. Il n'y a pas d'opération peek séparée.
Que se passe-t-il si je dépile une pile vide ?
Rien n'est retiré : l'animation vérifie que la pile n'est pas vide et signale qu'il n'y a rien à supprimer.
Le code est-il affiché ?
Oui, dans un panneau C++ redimensionnable qui surligne la ligne de chaque étape.

Outils associés