Erste Schritte Verkettete Liste will einfach nicht in meinen Schädel

R

Redbeard

Mitglied
Guten Tag liebe Leute,
ich bräuchte bitte einen Tipp oder einen Denkanstoß in die richtige Richtung. Ich zerbreche mir nun schon seit Wochen den Schädel über eine Aufgabe aus meinem Java-Kurs und bekomme ich es einfach nicht hin. Ich scheine da auch nicht allein zu sein, weil ich dieses Listing schon ein paar mal hier im Forum gefunden habe - nur kann ich mit den Lösungsansätzen dort nicht wirklich was anfangen. Hier erstmal da Listing und dann mein Lösungsansatz mit den Fragen dazu:

Java:
package liste;

class Listenelement {
        String daten;
        Listenelement naechster;
       
        void setDaten(String datenNeu) {
           
            daten = datenNeu;
            naechster = null;
        }

   
        void anhaengen(String datenNeu) {
       
            if (naechster == null) {
                naechster = new Listenelement();
                naechster.setDaten(datenNeu);
            }
   
            else
                naechster.anhaengen(datenNeu);
       
        }


        void ausgeben() {
            System.out.println(daten);
            if (naechster != null)
                naechster.ausgeben();
        }
    }

public class Liste {
    public static void main(String[] args) {

        Listenelement listenAnfang = new Listenelement();

       
        listenAnfang.setDaten("Element 1");

        for (int element = 2; element < 4; element++)
            listenAnfang.anhaengen("Element " + element);

        listenAnfang.ausgeben();
    }
}

Die Aufgabe lautet:
Erweitern Sie das Programm so, dass das Listenende beim Anhängen nicht immer wieder neu ermittelt werden muss, sondern neue Elemente direkt am Ende der Liste angehängt werden können. Hängen Sie zum Test mindestens 20 Elemente an.

Dazu ein paar Hilfestellungen:
• Sie müssen neben dem Anfang der Liste jetzt auch das Ende der Liste in einer Variablen speichern können.
• Erstellen Sie eine Methode, die Ihnen das aktuelle Ende der Liste zurückliefert.

Alternativ können Sie sich das Listenende auch von der Methode zum Anhängen liefern lassen.

• Setzen Sie den Wert der Variablen für das Listenende nach dem Anhängen neuer Elemente jeweils auf das aktuelle Ende der Liste und rufen Sie dann die Methode zum Anhängen neuer Listenelemente mit diesem Wert neu auf.

So weit so gut, die Aufgaben Stellung ist eigentlich klar. Nun mein Lösungsansatz, den ich aber nicht hinbekomme.

Ich würde die Klasse um ein Element erweitern, so dass Sie jetzt ein Feld "Listenelement letzter" enthält, welches ich nur im ersten Knoten speichern will, alle anderen sollen null sein. Wenn ich jetzt einen neuen Knoten anlegen will möchte ich ihm sagen, dass er ein neuen Knoten nach "letzter" anlegt und dann den neue angelegten Knoten in letzter referenzieren, aber ich bekomme es nicht hin.

Mache ich irgendwo einen Denkfehler?

Vielen Dank und viele Grüße
Red
 
D

DrZoidberg

Top Contributor
Ich bin mir nicht sicher, ob du die Variable "letzter" in der "Listenelement" Klasse hinzufügen sollst oder in der "main" Methode.
Aber in jedem Fall wüde ich damit anfangen, die "anhaengen" Methode so zu verändern, dass sie das letzte Listenelement zurückliefert.
 
J

Jardcore

Top Contributor
Ich würde behaupten das du 3 Klassen brauchst, "Liste", "ListenElement" und eine "Main" Klasse.
In der Main Klasse erstellst du deine Liste. Die Liste hat zwei Zeiger/Referenzen, "erstesElement" und "letztesElement" und die Methoden "anhaengen(ListenElement element)", "gibLetztesElement", "gibErstesElement".
Die Klasse "ListenElement" benötigt eine Referenz auf das nächste Element "ListenElement naechstesElement", dafür dann auch die getter und setter implementieren.

In "anhaengen" prüfst du ob das "ersteElement" null ist, wenn ja -->
erstesElement = element;
letztesElement = element;
Andernfalls:
letztesElement.setzeNaechstesElement(element);
letztesElement = element;

Das letzte Element bekommst du dann in der "gibLetztesElement" Methode durch ein "return letztes Element;"

Beste Grüße,
Jar
 
J

Jardcore

Top Contributor
Hab die Gedanken mal 1 zu 1 in Code gegossen... nur die Logik an der wichtigen Stelle hab ich mal für Übungszwecke ausgelassen :p
Java:
public class Element {
    private String data;
    private Element next;
 
    public Element(String data) {
        setData(data);
    }
 
    public Element getNext() {
        return next;
    }
 
    public void setNext(Element next) {
        this.next = next;
    }
 
    public String getData() {
        return data;
    }
 
    public void setData(String data) {
        this.data = data;
    }
 
    @Override
    public String toString() {
        return data;
    }
}

Java:
public class ListExample {
    public static void main(String[] args) {
        List list = new List();
     
        for(int i = 1; i <= 20; i++) {
            list.add(new Element("Data"+i));
        }
     
        System.out.println(list);
        System.out.println(list.getFirst());
        System.out.println(list.getLast());
    }
}
Java:
public class List {
    private Element first;
    private Element last;
 
    public Element add(Element element) {
        // hier fehlt noch die Logik
    }
 
    public Element getFirst() {
        return first;
    }
 
    public Element getLast() {
        return last;
    }
 
    @Override
    public String toString() {
        StringBuilder sb = new StringBuilder();
        Element cur = first;
        while(cur != null) {
            sb.append(cur);
            sb.append(" ");
            cur = cur.getNext();
        }
        return sb.toString();
    }
}

Ausgabe:
Code:
Data1 Data2 Data3 Data4 Data5 Data6 Data7 Data8 Data9 Data10 Data11 Data12 Data13 Data14 Data15 Data16 Data17 Data18 Data19 Data20
Data1
Data20
 
J

Jardcore

Top Contributor
Ich wollte ja nicht die Aufgabe für ihn erledigen :)

Frage an den TE, ist der Code den du gepostet hast schon von dir verändert oder der vorgegebene?
 
R

Redbeard

Mitglied
Es ist der vorgegebene Code. Meine Herangehensweise sieht mittlerweile so aus (habe die Namen der Variablen (für mich) sprechender gemacht:

Java:
package java05b_05_02;


class Element {
        String data;
        Element nextElement;
        Element previousElement;
        Element lastElement;
        Element firstElement;

        Element getLastElement() {
            return lastElement;
        }
       
        void setLastElement(Element lastElement) {
            this.lastElement = lastElement;
        }

        Element getFirstElement() {
            return firstElement;
        }
       
        void setFirstElement(Element firstElement) {
            this.firstElement = firstElement;
        }
       
        Element getPreviousElement() {
            return previousElement;
        }
       
        void setPreviousElement(Element previousElement) {
            this.previousElement = previousElement;
        }
       
        Element getNextElement() {
            return nextElement;
        }
       
        void setNextElement(Element nexElement) {
            this.nextElement = nextElement;
        }
       
        String getData() {
            return data;
        }
        void setData(String data) {
            this.data = data;
        }
   
       
        void addElement(Element list) {
           
            Element knoten = new Element();
            setLastElement(knoten);
       
           
        }
       
        void output() {
            System.out.println(data);
            if (nextElement != null)
                nextElement.output();
        }
       
       
    }

public class Java05b_05_02 {
    public static void main(String[] args) {
   
        Element list = new Element();
        list.setFirstElement(list);
        list.setLastElement(list);
        list.setPreviousElement(null);
        list.setNextElement(null);
        list.setData("Element 1");
        list.addElement(list);
       
       
    }
}
 
JStein52

JStein52

Top Contributor
Und als zweites frage ich mich gerade: wo verknüpfst du die Elemente eigentlich miteiander ?
 
R

Redbeard

Mitglied
Sorry, soweit bin ich mit dem neuen Code noch nicht. Habe das hier nur gepostet um meinen Gedankengang und meine Herangehensweise zu verdeutlichen. War doof formuliert von mir.
 
J

Jardcore

Top Contributor
Du brauchst übrigens keine Getter / Setter wenn alle deine Attribute / Variablen die gleiche Sichtbarkeit haben wie deine Getter / Setter :)

Und scheinbar hast du uns nicht alles mitgeteilt, mittlerweile hat sich ja auch noch ein previous eingeschlichen^^ also eine doppelt verkettete Liste?

Edit: Irgendwie kann ich auch nicht nachvollziehen wieso ein Element Kenntnis über irgendwas erstes und irgendwas letztes haben soll. Ich könnte mir nur vorstellen, dass es zwei boolean flags gibt isFirst, isLast, welche angeben ob das Element an erster oder letzer Stelle ist.
 
Zuletzt bearbeitet:
J

Jardcore

Top Contributor
Hier nochmal mehr auf dein ursprünglichen Code gemünzt, also 2 Klassen aber die Klasse mit der Main Methode ist auch die Liste.

Java:
public class List {
    private Element firstElement;
    private Element lastElement;
 
    public static void main(String[] args) {
        List list = new List();
     
        for(int i = 1; i <= 20; i++) {
            list.addElement(new Element("Data"+i));
        }
     
        System.out.println(list);
        System.out.println(list.getFirstElement());
        System.out.println(list.getLastElement());
     
    }
 
    public Element addElement(Element element) {
        if(firstElement == null) {
            firstElement = element;
        } else {
            lastElement.setNext(element);
        } 

        lastElement = element;
     
        return getLastElement();
    }
 
    public Element getLastElement() {
        return lastElement;
    }
 
    public Element getFirstElement() {
        return firstElement;
    }
 
    @Override
    public String toString() {
        StringBuilder sb = new StringBuilder();
        Element current = firstElement;
        while(current != null) {
            sb.append(current);
            sb.append(" ");
            current = current.getNext();
        }
        return sb.toString();
    }
}
Java:
public class Element {
    private String data;
    private Element nextElement;
 
    public Element(String data) {
        setData(data);
    }
 
    public String getData() {
        return data;
    }
 
    public void setData(String data) {
        this.data = data;
    }
 
    public Element getNextElement() {
        return nextElement;
    }
 
    public void setNextElement(Element nextElement) {
        this.nextElement = nextElement;
    }
 
    @Override
    public String toString() {
        return data;
    }
}

Beachte die toString() Methoden, die dir eine einfache Ausgabe erlauben.
Dann kannst du einfach System.out.println(ELEMENT); aufrufen

Vielleicht kommt das irgendwann noch, aber als Erweiterung könnte ich mir die Lösch-Operation vorstellen, das Implementieren einer size() Methode. Die Erweiterung zu einer doppelt verketteten Liste oder zu einem Ring. Und zu guter letzt natürlich der Umbau zu einer generischen Liste.
 
Ähnliche Java Themen
  Titel Forum Antworten Datum
C Methoden Über eine einfach verkettete Liste Java Basics - Anfänger-Themen 8
O Einfach verkettete Liste - Revert Methode Java Basics - Anfänger-Themen 1
S Einfach verkettete Liste Element an bestimmter Position einfügen Java Basics - Anfänger-Themen 24
K Einfach Verkettete Liste - addFirst() Java Basics - Anfänger-Themen 7
X Einfach verkettete Liste, keine Fehlermeldung Programm friert ein Java Basics - Anfänger-Themen 4
X Einfach Verkettete Liste Java Basics - Anfänger-Themen 16
K Datentypen Einfach/Doppelt verkettete Liste Java Basics - Anfänger-Themen 4
N einfach verkettete liste fehler Java Basics - Anfänger-Themen 5
N einfach verkettete liste Java Basics - Anfänger-Themen 3
B OOP Einfach verkettete Liste - rekursive Methoden Java Basics - Anfänger-Themen 1
S einfach verkettete Liste Java Basics - Anfänger-Themen 19
T Einfach verkettete Liste: Wie Elemente löschen? Java Basics - Anfänger-Themen 4
D Einfach verkettete Liste Java Basics - Anfänger-Themen 20
C einfach verkettete Liste -> Elemente vertauschen Java Basics - Anfänger-Themen 2
R einfach verkettete Liste, intersect Java Basics - Anfänger-Themen 4
E einfach verkettete liste, nullPointerException Java Basics - Anfänger-Themen 5
Y Einfügen in eine doppelt verkettete Liste Java Basics - Anfänger-Themen 8
A Doppelt verkettete Liste rückwärts ausgeben Java Basics - Anfänger-Themen 17
D Doppelt Verkettete Zirkular-Liste Java Basics - Anfänger-Themen 1
A Verkettete Liste Java Basics - Anfänger-Themen 2
B Doppelt verkettete Liste implementieren Java Basics - Anfänger-Themen 8
L verkettete Liste Java Basics - Anfänger-Themen 15
scratchy1 doppelt verkettete Liste testen Java Basics - Anfänger-Themen 8
R Methoden Entferne alle identische Knoten (Typ String) aus verkettete Liste Java Basics - Anfänger-Themen 8
H Verkettete Liste Java Basics - Anfänger-Themen 7
N Verkettete liste rückwärts ausgeben Java Basics - Anfänger-Themen 5
K Verkettete Liste und seine Methoden Java Basics - Anfänger-Themen 1
N Verkettete Liste implementieren Java Basics - Anfänger-Themen 5
G Verkettete Liste - Neu erzeugte Elemente werden nicht ausgegeben Java Basics - Anfänger-Themen 5
B Doppelt Verkettete Liste - Ist alles gut so? Java Basics - Anfänger-Themen 3
C Verkettete Liste - sortiert einfügen Java Basics - Anfänger-Themen 7
U Datentypen Doppelt verkettete Liste implementieren Java Basics - Anfänger-Themen 13
J Methoden Doppelt verkettete Liste remove(Object) Java Basics - Anfänger-Themen 8
B OOP Über eine doppelt verkettete Liste iterieren Java Basics - Anfänger-Themen 4
hooked Verkettete Liste / linked list Java Basics - Anfänger-Themen 2
L Doppelt verkettete Liste Java Basics - Anfänger-Themen 6
J Eine Art verkettete Liste aber mit teils mehr als einem Nachfolger Java Basics - Anfänger-Themen 8
V Verkettete Liste rückwärts ausgeben Java Basics - Anfänger-Themen 3
R doppelt verkettete Liste aus Arrays erstellen Java Basics - Anfänger-Themen 1
G 2 Aufgabe rund um eine verkettete Liste Java Basics - Anfänger-Themen 2
O Verkettete Liste Java Basics - Anfänger-Themen 10
E Methoden auf von Methoden erstellte Objekte zugreifen (verkettete Liste) Java Basics - Anfänger-Themen 10
S Doppelt verkettete Liste Java Basics - Anfänger-Themen 3
G Doppelt Verkettete Liste Java Basics - Anfänger-Themen 2
A Doppelt Verkettete Liste Java Basics - Anfänger-Themen 16
E doppelt verkettete liste Java Basics - Anfänger-Themen 10
V Verkettete Liste. Java Basics - Anfänger-Themen 7
K Verkettete Liste - Methode entwerfen Java Basics - Anfänger-Themen 14
S Verkettete Liste rückwärts ausgeben Java Basics - Anfänger-Themen 12
B Insertionsort verkettete Liste Java Basics - Anfänger-Themen 4
B Stack in eine verkettete Liste pushen Java Basics - Anfänger-Themen 4
R verkettete liste ansEndeSchieben Java Basics - Anfänger-Themen 13
T Verkettete Liste Java Basics - Anfänger-Themen 14
A Klassen Innere Klassen, verkettete Liste Java Basics - Anfänger-Themen 9
B Zweifach-verkettete Liste umkehren Java Basics - Anfänger-Themen 6
X verkettete Liste Java Basics - Anfänger-Themen 13
E Datentypen Doppelt verkettete Liste Java Basics - Anfänger-Themen 10
P Einfügen in doppelt verkettete Liste Java Basics - Anfänger-Themen 7
kae verkettete Liste Java Basics - Anfänger-Themen 5
S Queue als doppelt verkettete Liste Java Basics - Anfänger-Themen 2
S Stack als verkettete liste/ toString methode Java Basics - Anfänger-Themen 3
B OOP Verkettete Liste Java Basics - Anfänger-Themen 7
R verkettete liste Java Basics - Anfänger-Themen 5
M Verkettete Liste Java Basics - Anfänger-Themen 4
M verkettete liste Java Basics - Anfänger-Themen 7
N doppelt verkettete liste einfügen Java Basics - Anfänger-Themen 7
G verkettete Liste - invertieren Java Basics - Anfänger-Themen 2
B verkettete Liste Java Basics - Anfänger-Themen 8
S zyklisch verkettete Liste erstellen Java Basics - Anfänger-Themen 3
O Stack Implementierung als verkettete Liste Java Basics - Anfänger-Themen 8
W Doppelt verkettete Liste implementieren Java Basics - Anfänger-Themen 2
J verkettete Liste Java Basics - Anfänger-Themen 2
DasDogma Verkettete Liste - Element löschen Java Basics - Anfänger-Themen 2
H Verkettete Liste Java Basics - Anfänger-Themen 5
M verkettete Liste auslesen Java Basics - Anfänger-Themen 7
K eigene verkettete Liste Java Basics - Anfänger-Themen 4
G Doppelt verkettete, generische Liste Java Basics - Anfänger-Themen 11
A Eine verkettete Liste Java Basics - Anfänger-Themen 43
G verkettete lineare Liste Java Basics - Anfänger-Themen 2
L verkettete Liste - Ausgabeproblem Java Basics - Anfänger-Themen 2
G Wie kann ich eine verkettete Liste in ein JTable einfügen? Java Basics - Anfänger-Themen 7
D doppelt verkettete Liste Java Basics - Anfänger-Themen 16
S Doppelt Verkettete Liste Java Basics - Anfänger-Themen 7
R ArrayList Objekt -> verkettete Liste Java Basics - Anfänger-Themen 4
R verkettete Liste Java Basics - Anfänger-Themen 13
R verkettete Liste in und aus Datei Java Basics - Anfänger-Themen 5
M Doppelt verkettete Liste Zeiger Vorgänger beim Einfügen Java Basics - Anfänger-Themen 2
J doppelt verkettete Liste Java Basics - Anfänger-Themen 5
L doppelt verkettete Liste Java Basics - Anfänger-Themen 6
0 Binärbaum als verkettete Liste Java Basics - Anfänger-Themen 3
B Doppelt verkettete Liste implementieren Java Basics - Anfänger-Themen 12
G Dopplelt verkettete liste Java Basics - Anfänger-Themen 4
B Doppelt verkettete Liste Java Basics - Anfänger-Themen 16
R Datentyp Ring - zyklisch doppelt verkettete Liste - HILFE! Java Basics - Anfänger-Themen 12
S Queue als verkettete Liste Java Basics - Anfänger-Themen 9
R doppelt verkettete Liste Java Basics - Anfänger-Themen 8
F doppelt verkettete liste! Java Basics - Anfänger-Themen 8
M Verkettete Liste (schritt für schritt durchlauf) Java Basics - Anfänger-Themen 5
R doppelt verkettete azyklische Liste Java Basics - Anfänger-Themen 2
Z Zyklisch verkettete Liste Java Basics - Anfänger-Themen 4

Ähnliche Java Themen

Anzeige

Neue Themen


Oben