added ws202425 courses

2023_Informatik_b/9/queue_list.cpp

@@ -0,0 +1,134 @@
+#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;
+}