Generischer Stack

Teil des Abschnitts Objektorientierte Programmierung der Rust-Journey von Coddy. Lektion 59 von 61.

Aufgabe

Einfach

Ein stack ist eine grundlegende Datenstruktur, die dem Prinzip „Last In, First Out“ (LIFO) folgt: Das zuletzt hinzugefügte Element wird als Erstes entfernt. Stell dir einen Stapel Teller vor: Du fügst Teller oben hinzu und entfernst sie ebenfalls oben.

Wir erstellen eine generische Stack-Datenstruktur, die jeden Typ von element aufnehmen kann! Ein stack folgt dem Prinzip „Last In, First Out“, wie ein Bücherstapel, bei dem du nur oben etwas hinzufügen oder entfernen kannst.

Du organisierst deinen Code auf zwei Dateien:

stack.rs: Define deine generische Stack<T>-struct, die intern einen Vec<T> zum Speichern von Elementen uses. Implement drei methods: new, um einen leeren stack zu erstellen, push, um ein element oben hinzuzufügen, und pop, um das oberste element zu entfernen und zurückzugeben (mit Rückgabe von Option<T>, da der stack leer sein kann).
main.rs: Binde dein stack-Modul ein und demonstriere, wie dein Stack mit integers funktioniert. Create einen stack, füge die bereitgestellten numbers hinzu, entferne anschließend Elemente mit pop und gib jedes davon aus. Verwende unwrap_or, um das von pop zurückgegebene Option zu handle; wenn der stack leer ist, verwende -1 als Standardwert.

Ein stack benötigt zwei wesentliche Operationen:

push: fügt ein element oben auf dem stack hinzu
pop: entfernt das oberste element und gibt es zurück

Die pop-Methode sollte ein Option<T> zurückgeben, da der stack leer sein kann. Der Typ Vec verfügt bereits über eine pop-Methode, die Option<T> zurückgibt und die du in deiner Implementierung verwenden kannst.

Dein stack sollte folgendermaßen funktionieren: Wenn du die Werte 10, 20 und 30 (in dieser order) mit push hinzufügst, sollte dreimaliges pop 30, 20 und 10 (in umgekehrter Reihenfolge) liefern. Ein viertes pop bei einem leeren stack sollte den Standardwert zurückgeben.

Gib jeden entfernten Wert in einer eigenen Zeile aus:

Zum Beispiel bei den Eingaben 5, 15 und 25:

Du erhältst drei Eingaben: drei integers, die auf den stack gelegt werden sollen (parse jede Eingabe als i32). Nachdem alle drei hinzugefügt wurden, führe viermal pop aus, um sowohl erfolgreiche Entnahmen als auch den Fall eines leeren stacks zu demonstrieren.

Probier es selbst

mod stack;

use stack::Stack;

fn main() {
    // Lese drei Ganzzahlen von der Eingabe
    let mut input1 = String::new();
    std::io::stdin().read_line(&mut input1).expect("Failed to read line");
    let num1: i32 = input1.trim().parse().expect("Invalid number");

    let mut input2 = String::new();
    std::io::stdin().read_line(&mut input2).expect("Failed to read line");
    let num2: i32 = input2.trim().parse().expect("Invalid number");

    let mut input3 = String::new();
    std::io::stdin().read_line(&mut input3).expect("Failed to read line");
    let num3: i32 = input3.trim().parse().expect("Invalid number");

    // TODO: Erstelle einen neuen Stack

    // TODO: Lege die drei Zahlen auf den Stack (num1, num2, num3 in dieser Reihenfolge)

    // TODO: Führe Pop viermal aus und gib jedes Ergebnis aus
    // Verwende unwrap_or(-1), um den Fall eines leeren Stacks zu behandeln
}