Eine verkettete Liste

Diese Seite verwendet Cookies. Durch die Nutzung unserer Seite erklären Sie sich damit einverstanden, dass wir Cookies setzen. Weitere Informationen

Aufgrund der Corona-Krise: Die Veröffentlichung von Stellenangeboten und -gesuchen ist bis 31.12.2020 kostenfrei. Das beinhaltet auch Angebote und Gesuche von und für Freischaffende und Selbstständige.

  • Eine verkettete Liste

    Hallo,
    ich weiß nicht, ob das Thema schonmal hier erfragt oder behandelt wurde?!
    Ich bin auch Anfänger und bin dabei Swift zu lernen.

    Ich muss ein einfach verkettete Liste mit Objekten so erweitern, dass das Listenende beim Anhängen neuer Elemente nicht immer wieder neu ermittelt werden muss, sondern neue Elemente direkt am Ende der Liste angehängt werden können.

    Die Hilfestellung dazu lautet:

    1. Ich muss neben dem Anfang der Liste jetzt auch das Ende der Liste in einer Instanz speichern können.
    2. Setze diese Instanz nach dem Anhängen neuer Elemente jeweils auf das aktuelle Ende der Liste.

    Der Ursprüngliche Code sieht so aus:


    import Foundation

    // die Klasse für die Listenelemente
    // jetzt auch mit Methoden
    class Listenelement {
    var daten = ""
    // die Referenz auf das nächste Element
    var naechster: Listenelement?

    // die Daten für ein Element setzen
    // übergeben wird die Zeichenkette
    func setDaten(datenNeu: String) {
    // die Zeichenkette setzen
    daten = datenNeu
    // das Ende markieren
    naechster = nil
    }

    // ein neues Element am Ende der Liste anhängen
    // übergeben wird die Zeichenkette
    // das eigentliche Einfügen erfolgt über die Methode
    // setDaten()
    // die Methode ruft sich rekursiv auf, bis das Ende erreicht ist
    func anhaengen(datenNeu: String) {
    // wenn das Ende erreicht ist, ein neues Element erzeugen
    if naechster == nil {
    naechster = Listenelement()
    naechster!.setDaten(datenNeu: datenNeu)
    }
    // sonst ruft sich die Methode selbst wieder auf
    else {
    naechster!.anhaengen(datenNeu: datenNeu)
    }

    // zur Veranschaulichung der Rekursion
    print("Daten \(datenNeu) wurde eingefügt!")
    }

    // die Ausgabe der kompletten Liste
    // die Methode ruft sich ebenfalls rekursiv auf, bis das Ende
    // erreicht ist
    func ausgeben() {
    print(daten)
    if naechster != nil {
    naechster!.ausgeben()
    }
    }
    }

    // ein neues Listenelement erzeugen
    let listenAnfang = Listenelement()

    // die Daten im ersten Listenelement setzen
    listenAnfang.setDaten(datenNeu: "Element 1")

    // weitere Elemente in einer Schleife anfügen
    for element in 2 ..< 10 {
    listenAnfang.anhaengen(datenNeu: "Element " + String(element))
    }

    // die Liste ausgeben
    listenAnfang.ausgeben()


    Meine veränderte Version:

    import Foundation

    //die Klasse für die Listenelemente
    //jetzt auch mit Methoden
    class Listenelement {
    var daten = ""
    //die Referenz auf das nächste Element
    var naechster: Listenelement?
    var letzter: Listenelement?

    //die Daten für ein Element setzen
    //übergeben wird die Zeichenkette
    func setDaten(datenNeu: String) {
    //die Zeichenkette setzen
    daten = datenNeu
    //das Ende markieren
    naechster = nil
    }

    //ein neues Element am Ende der Liste anhängen
    //übergeben wird die Zeichenkette
    //das eigentliche Einfügen erfolgt über die Methode setDaten()

    //die Methode ruft sich rekursiv auf, bis das Ende erreicht ist
    func anhaengen(datenNeu: String) {
    //wenn das Ende erreicht ist, ein neues Element erzeugen
    if naechster == nil {
    naechster = Listenelement()
    naechster!.setDaten(datenNeu: datenNeu)
    letzter = naechster
    }
    //sonst ruft sich die Methode selbst wieder auf
    else {
    naechster!.anhaengen(datenNeu: datenNeu)
    letzter = naechster
    }
    //zur Veranschaulichung der Rekursion
    print("Daten \(datenNeu) wurden eingefügt.")
    }

    // die Ausgabe der kompletten Liste
    // die Methode ruft sich ebenfalls rekursiv auf, bis das Ende erreicht ist
    func ausgeben() {
    print(daten)
    if naechster != nil {
    naechster!.ausgeben()
    }
    }
    }

    //ein neues Listenelement erzeugen
    let listenAnfang = Listenelement()
    let listenEnde = Listenelement()

    //die Daten im ersten Listenelement setzen
    //listenAnfang.setDaten(datenNeu: "Element 1")
    listenEnde.setDaten(datenNeu: "Test 1")

    //weitere Elemente in einer Schleife anfügen
    for element in 2 ..< 10 {
    //listenAnfang.anhaengen(datenNeu: "Element " + String(element))
    listenEnde.anhaengen(datenNeu: "Test " + String(element))
    }

    //die Liste ausgeben
    //listenAnfang.ausgeben()
    listenEnde.ausgeben()

    Ist das überhaupt richtig, was ich hier gemacht habe????

    Danke!
  • Also ich versuche jetzt nicht, Deinen Code im Detail zu verstehen, nur so viel:
    • Die Verwendung des Code-Tags würde dies sehr vereinfachen
    • Einrückung des Source-Codes je nach Blocktiefe erhöht zusätzlich die Lesbarkeit
    • Das Listen-Ende muss doch nicht in jedem Element, sondern nur einmalig gespeichert werden
    • Wenn Du einen Pointer auf das letzte Element hast, brauchst Du doch keine Rekursion mehr; einfach an letztes Element anhängen, dieses aktualisieren, fertig
    Mein Credo - wie so häufig an solchen Stellen - ist, nicht direkt coden, sondern erst einmal strukturiert überlegen ... z. B. mit etwas Pseudo-Code und/oder einer Zeichnung. Old school eben :)

    Mattes
    Diese Seite bleibt aus technischen Gründen unbedruckt.