Stapel

Einen aus Knoten aufgebauten C++-Stapel Schritt für Schritt durchgehen.

Alles wird in diesem Browser simuliert; nichts wird an einen Server gesendet.

Werte

Neuen Knoten erstellen

Neuen Knoten erstellen

n_ = 0

Der Stapel ist leer

  • Gerade hinzugefügt
  • Wird gerade entfernt

Schritt 1 / 47

Code

#include <iostream>
using namespace std;
class Nodo { // Ein Knoten enthält die Daten und einen Zeiger auf den nächsten
private: // Private Attribute: nur die Methoden greifen darauf zu
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: // Der zuletzt abgelegte Knoten ist die Spitze
Nodo* cima_; // Oberster Knoten
int n_; // Anzahl der Knoten
public:
Pila() : cima_(nullptr), n_(0) {}
// Destructor (no se anima)
~Pila() {
while (cima_ != nullptr) desapilar();
}
void apilar(int valor) { // Oben ablegen: O(1)
Nodo* nuevo = new Nodo(valor); // Knoten erzeugen
nuevo->setSiguiente(cima_); // Der neue Knoten zeigt auf die alte Spitze
cima_ = nuevo; // cima_ zeigt jetzt auf den neuen Knoten
n_++;
}
void desapilar() { // Oberstes entfernen: O(1)
if (cima_ == nullptr) return; // Leerer Stapel: nichts zu entfernen
Nodo* temp = cima_; // Spitze merken, um sie freizugeben
cima_ = cima_->getSiguiente(); // cima_ rückt zum nächsten Knoten nach unten
delete temp; // Speicher freigeben
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;
}

Diese Stack-Visualisierung zeigt, wie eine LIFO-Struktur funktioniert, bei der das zuletzt abgelegte Element als erstes entnommen wird. Der Stack besteht aus C++-Knoten und einem Zeiger namens cima_, der auf den obersten Knoten zeigt. Sie können eine zufällige Folge erzeugen oder eigene Push- und Pop-Operationen hinzufügen, insgesamt bis zu 12. Beim Abspielen sehen Sie, wie der Knoten erzeugt und mit dem alten Top verknüpft wird, wie cima_ wandert und wie der Speicher freigegeben wird, während die passende Codezeile hervorgehoben ist. Pop auf einem leeren Stack wird deutlich gekennzeichnet. Alles läuft in Ihrem Browser und nichts wird irgendwohin gesendet.

So funktioniert es

  1. Wählen Sie die Größe und drücken Sie Mischen, um eine zufällige Folge von Operationen zu erzeugen, oder beginnen Sie mit einer leeren Liste.
  2. Wählen Sie Push oder Pop, geben Sie beim Push den Wert ein und drücken Sie Hinzufügen, um die Operation anzuhängen.
  3. Drücken Sie Abspielen oder bewegen Sie sich mit den Schaltflächen für vorigen und nächsten Schritt.
  4. Beobachten Sie den Zähler n_, den Zeiger cima_ und das Feld, das als neu hinzugekommen oder abgehend markiert ist.

Häufig gestellte Fragen

Was bedeutet LIFO?
Last In, First Out: Das zuletzt abgelegte Element kommt als erstes wieder heraus, Sie arbeiten also immer nur mit der Spitze des Stacks.
Welche Operationen gibt es?
Push zum Hinzufügen eines Werts und Pop zum Entfernen des obersten. Eine eigene Peek-Operation gibt es nicht.
Was passiert, wenn ich Pop auf einem leeren Stack ausführe?
Es wird nichts entfernt: Die Animation prüft, dass der Stack nicht leer ist, und meldet, dass nichts zu entfernen ist.
Wird der Code angezeigt?
Ja, in einem in der Größe veränderbaren C++-Bereich, der für jeden Schritt die passende Zeile hervorhebt.

Verwandte Tools