135 lines
3.5 KiB
C++
135 lines
3.5 KiB
C++
#include <iostream>
|
|
|
|
// Definiere eine Vorlage für die Klasse QueueList.
|
|
// Diese Klasse implementiert eine Warteschlange mit einer verketteten Liste.
|
|
template <typename E>
|
|
class QueueList
|
|
{
|
|
private:
|
|
// Definition eines Knotens, der einen Wert und einen Zeiger auf den nächsten Knoten hat.
|
|
struct Node
|
|
{
|
|
E value;
|
|
Node *next;
|
|
};
|
|
|
|
// Zeiger auf den Anfang und das Ende der Warteschlange und eine Zählvariable für die Größe.
|
|
Node *head;
|
|
Node *tail;
|
|
int count;
|
|
|
|
public:
|
|
// Konstruktor initialisiert Zeiger und Zähler mit Nullwerten.
|
|
QueueList() : head(nullptr), tail(nullptr), count(0) {}
|
|
|
|
// Destruktor löscht alle Elemente in der Warteschlange.
|
|
// Voraussetzung: keine
|
|
// Effekt: Alle Elemente in der Warteschlange werden gelöscht
|
|
// Ergebnis: Keines
|
|
~QueueList()
|
|
{
|
|
while (!is_empty())
|
|
{
|
|
dequeue();
|
|
}
|
|
}
|
|
|
|
// Überprüft, ob die Warteschlange leer ist.
|
|
// Voraussetzung: keine
|
|
// Effekt: Keiner
|
|
// Ergebnis: Wenn die Warteschlange leer ist, ist 'true' geliefert, sonst ist 'false' geliefert
|
|
bool is_empty() const
|
|
{
|
|
return count == 0;
|
|
}
|
|
|
|
// Gibt die Größe der Warteschlange zurück.
|
|
// Voraussetzung: keine
|
|
// Effekt: Keiner
|
|
// Ergebnis: Die Anzahl der Elemente in der Warteschlange wird zurückgegeben
|
|
unsigned size() const
|
|
{
|
|
return count;
|
|
}
|
|
|
|
// Gibt das erste Element der Warteschlange zurück.
|
|
// Voraussetzung: Die Warteschlange ist nicht leer
|
|
// Effekt: Keiner
|
|
// Ergebnis: Das vorderste Element wird zurückgegeben
|
|
E front() const
|
|
{
|
|
if (is_empty())
|
|
{
|
|
throw std::runtime_error("Queue is empty");
|
|
}
|
|
return this->head->value;
|
|
}
|
|
|
|
// Fügt ein Element am Ende der Warteschlange ein.
|
|
// Voraussetzung: Keine
|
|
// Effekt: Das übergebene Element wird hinten in die Warteschlange eingefügt
|
|
// Ergebnis: Keines
|
|
void enqueue(E x)
|
|
{
|
|
Node *newNode = new Node();
|
|
newNode->value = x;
|
|
newNode->next = nullptr;
|
|
|
|
if (tail != nullptr)
|
|
{
|
|
tail->next = newNode;
|
|
}
|
|
|
|
tail = newNode;
|
|
|
|
if (is_empty())
|
|
{
|
|
head = newNode;
|
|
}
|
|
|
|
count++;
|
|
}
|
|
|
|
// Entfernt das erste Element der Warteschlange und gibt seinen Wert zurück.
|
|
// Voraussetzung: Die Warteschlange ist nicht leer
|
|
// Effekt: Das vorderste Element wird aus der Warteschlange entfernt
|
|
// Ergebnis: Das vorderste Element wird zurückgegeben
|
|
E dequeue()
|
|
{
|
|
if (is_empty())
|
|
{
|
|
throw std::runtime_error("Queue is empty");
|
|
}
|
|
|
|
Node *tempNode = head;
|
|
E value = head->value;
|
|
|
|
head = head->next;
|
|
|
|
if (head == nullptr)
|
|
{
|
|
tail = nullptr;
|
|
}
|
|
|
|
delete tempNode;
|
|
count--;
|
|
|
|
return value;
|
|
}
|
|
};
|
|
|
|
int main()
|
|
{
|
|
// Erstellt eine Warteschlange und fügt die Werte 3, 5 und 2 hinzu. Dann wird das vorderste Element angezeigt und zwei Elemente werden entfernt.
|
|
// Überprüft schließlich, ob die Warteschlange leer ist.
|
|
QueueList<int> q;
|
|
q.enqueue(1);
|
|
q.enqueue(2);
|
|
q.enqueue(3);
|
|
std::cout << q.front() << std::endl; // Erwartetes Ergebnis: 1
|
|
std::cout << q.dequeue() << std::endl; // Erwartetes Ergebnis: 1
|
|
std::cout << q.dequeue() << std::endl; // Erwartetes Ergebnis: 2
|
|
std::cout << q.is_empty() << std::endl; // Erwartetes Ergebnis: 0
|
|
std::cout << std::endl;
|
|
}
|