Warteschlange

Eine aus Knoten aufgebaute C++-Warteschlange 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

Die Warteschlange ist leer

  • Gerade hinzugefügt
  • Wird gerade entfernt

Schritt 1 / 54

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 Cola {
private: // frente_ verlässt als Nächstes die Schlange, final_ ist der zuletzt Angekommene
Nodo* frente_; // Erster Knoten der Warteschlange
Nodo* final_; // Letzter Knoten der Warteschlange
int n_; // Anzahl der Knoten
public:
Cola() : frente_(nullptr), final_(nullptr), n_(0) {}
// Destructor (no se anima)
~Cola() {
while (frente_ != nullptr) desencolar();
}
void encolar(int valor) { // Hinten einreihen: O(1)
Nodo* nuevo = new Nodo(valor); // Knoten erzeugen
if (final_ == nullptr) { // Ist die Warteschlange leer?
frente_ = final_ = nuevo; // Es ist der einzige Knoten: frente_ und final_ zeigen darauf
} else {
final_->setSiguiente(nuevo); // Der letzte Knoten zeigt auf den neuen
final_ = nuevo; // final_ zeigt jetzt auf den neuen Knoten
}
n_++;
}
void desencolar() { // Vorne entnehmen: O(1)
if (frente_ == nullptr) return; // Leere Warteschlange: nichts zu entfernen
Nodo* temp = frente_; // Vordersten Knoten merken, um ihn freizugeben
frente_ = frente_->getSiguiente(); // frente_ rückt zum nächsten Knoten vor
if (frente_ == nullptr) final_ = nullptr; // Warteschlange ist leer: final_ zeigt auf nichts mehr
delete temp; // Speicher freigeben
n_--;
}
// Muestra la cola del frente al final
void imprimir() const {
cout << "frente ->";
for (Nodo* p = frente_; p != nullptr; p = p->getSiguiente())
cout << " " << p->getDato();
cout << endl;
}
};
int main() {
Cola cola;
cola.encolar(3);
cola.encolar(6);
cola.encolar(9);
cola.imprimir(); // frente -> 3 6 9
cola.desencolar();
cola.imprimir(); // frente -> 6 9
cola.encolar(1);
cola.imprimir(); // frente -> 6 9 1
return 0;
}

Diese Queue-Visualisierung erklärt eine FIFO-Struktur, bei der das zuerst hineingekommene Element als erstes wieder herauskommt. Die Warteschlange besteht aus C++-Knoten und zwei Zeigern: frente_ zeigt auf das nächste Element, das die Schlange verlässt, und final_ auf das zuletzt eingefügte. Sie können eine zufällige Folge mischen oder selbst Enqueue- und Dequeue-Operationen hinzufügen, bis zu 12. Die Animation deckt den Sonderfall einer leeren Warteschlange ab, zeigt, wie der letzte Knoten mit dem neuen verknüpft wird, und wann final_ nach dem Leeren zu nullptr wird. Jeder Schritt hebt seine Codezeile hervor, und alles wird in Ihrem Browser berechnet.

So funktioniert es

  1. Wählen Sie die Größe und drücken Sie Mischen, um zufällige Operationen zu erzeugen, oder fügen Sie eigene hinzu.
  2. Wählen Sie Enqueue oder Dequeue, geben Sie beim Enqueue den Wert ein und drücken Sie Hinzufügen.
  3. Spielen Sie die Animation ab oder gehen Sie mit den Steuerelementen Schritt für Schritt vor.
  4. Verfolgen Sie die Zeiger frente_ und final_, den Zähler n_ und die hervorgehobene C++-Zeile.

Häufig gestellte Fragen

Was bedeutet FIFO?
First In, First Out: Die Elemente verlassen die Warteschlange in der Reihenfolge, in der sie ankamen, wie Menschen in einer Schlange.
Wie unterscheidet sie sich von einem Stack?
Eine Queue fügt hinten ein und entfernt vorn, während ein Stack beides an der Spitze erledigt.
Was passiert, wenn das letzte Element entnommen wird?
Die Warteschlange wird leer, final_ wird auf nullptr gesetzt, und der Speicher des Knotens wird freigegeben.

Verwandte Tools