Java Einfach verkettete Generic Liste

FrazeColder

Lt. Commander
Registriert
Okt. 2013
Beiträge
1.718
Hey Community,

Ich komme irgendwie mit dem next und dem vorgängerZeiger nicht klar...

Mir ist es ein rätsel, woher eclipse wissen soll, welches Elemen next sein soll und welches das Vorgänger sein soll...
Zudem habe ich in der Methode append das Problem, dass sich, nur wenn er in den Else-Zweig springt, die Node immer wieder selber überschreibt und nicht auf die nächste zeigt...
Und wenn es in den if-Zweig springt, hat dieses Element kein next bzw es ist null...

Wo sind meine Fehler...

Hier mal mein Code:
Code:
package Listen;

public class Liste<E> {

	private Link<E> anfang;
	private Link<E> ende;
	private Link<E> vorgeangerZeiger;

	public Liste() {
	}

	public Link<E> naechstesElement() {
		return vorgeangerZeiger.getNext();
	}

	public void setzeAktuellerZeigerZurueck() {
		
	}

	public void insertElement(Link<E> oneNode) {
		Link<E> prevousListElement = vorgeangerZeiger;
		Link<E> nextListElement = vorgeangerZeiger.getNext().getNext();
		
		prevousListElement.setNext(oneNode);
		prevousListElement.getNext().setNext(nextListElement);
	}

	public void removeElement(Link<E> oneNode) {
		Link<E> nextListElement = oneNode.getNext();
		
		vorgeangerZeiger.setNext(oneNode);
		vorgeangerZeiger.getNext().setNext(nextListElement);
	}

	public void append(Link<E> oneNode) {
		if (isListEmpty() == true) {
			anfang = oneNode;
		} else {
			oneNode.setNext(vorgeangerZeiger);
			ende = oneNode;
		}

		oneNode.setNext(ende);
//		ende.setNext(vorgeangerZeiger);
	}

	public boolean searchElement(Link<E> oneNode) {

		Link<E> helper = anfang;
		
		while (helper != oneNode) {
			helper = helper.getNext();
		}
		
		if(helper == oneNode){
			return true;
		}else{
			return false;
		}		
	}

	public boolean isListEmpty() {
		return anfang == null;
	}
	
	public static void main(String[] args){
		Liste<String> liste = new Liste<String>();
		liste.append(new Link<String>("1"));
		liste.append(new Link<String>("2"));
		liste.append(new Link<String>("3"));
		liste.append(new Link<String>("4"));
		
		
		
		
	}

}

Code:
package Listen;

public class Link<E> {

	private E data;
	private Link<E> next;
	
	public Link(E data) {
		this.data = data;
	}

	public E getData() {
		return data;
	}

	public void setData(E data) {
		this.data = data;
	}

	public Link<E> getNext() {
		return next;
	}

	public void setNext(Link<E> next) {
		this.next = next;
	}
}

MfG und Danke :)
 
Hi,

Ich hätte ein paar Gegenfragen
* Wieso möchtest du es selbst implementieren? (Wieso nicht z.B. nicht LinkedList benutzen? - https://docs.oracle.com/javase/7/docs/api/java/util/LinkedList.html)
* Wieso implementierst du das Interface "List" nicht?
* Was war der gedankliche Unterschied zwischen den Methoden "insertElement" und "append"?
* Wieso möchtest du an besagte Methoden ein Link<E> Objekt übergeben? Ich hätte als übergabe Parameter an dieser Stelle nur "E" erwartet - "Link" sollte bei diesem Konstrukt doch eher eine innere Klasse sein -oder?

Edit:
Generell solltest du mal ein bischen auf deinen Stil achten...zum Beispiel:
if (isListEmpty() == true)
... soetwas schreibt man nicht, sondern...
if (isListEmpty())

Gruß Zoldyck
 
Zuletzt bearbeitet:
* Wieso möchtest du es selbst implementieren? (Wieso nicht z.B. nicht LinkedList benutzen? - https://docs.oracle.com/javase/7/doc...inkedList.html)

Weil der Tutor das so will, sollte auch die nächste Frage beantworten...

* Was war der gedankliche Unterschied zwischen den Methoden "insertElement" und "append"?
append soll ans Listenende ein Element dran hängen und insertElement soll: "(Aufgabensignatur) Fügt ein neues Element vor der aktuellen Position ein."

* Wieso möchtest du an besagte Methoden ein Link<E> Objekt übergeben? Ich hätte als übergabe Parameter an dieser Stelle nur "E" erwartet - "Link" sollte bei diesem Konstrukt doch eher eine innere Klasse sein -oder?
Was ist den der Unterschied?
Habe gerade in der UML Notation nachgeschaut und da steht tatsächlich bei allen Methoden in Liste<E> nur "E" und kein "Link<E>"...

Und jetzt bekomme ich nach der Änderung leider vieler dieser Fehler bei z.B. dem Aufruf von setNext oder getNext:
The method setNext(Link<E>) in the type Link<E> is not applicable for the arguments (E)
 
Zuletzt bearbeitet:
Das ist jetzt nicht böse gemeint, aber dir fehlt es an ein paar Stellen an Grundwissen -wie teilweise dein Code und deine Fragen zeigen. Ich bin mir nicht sicher ob dein Problem im Verständis einer LinkList liegt oder du das ganze einfach nicht auf Code mappen kannst.

Ich bin mir sehr sicher das dein Tutor nicht gesagt hat, das ihr nicht das Interface List<E> implementieren dürft -das würde auch keinen Sinn machen. Es zeigt eher das du das Konzept dahinter nicht kennst/verstehst. Im nachfolgenden ein weiterführender Link zu diesem Thema (auch die verlinkten Themen in der Kommentarsektion des ersten Posts beachten): http://stackoverflow.com/questions/2423783/what-is-sense-of-interface

Zu dem eigentlichen Problem -da ich nicht weiß wo ich anfangen soll (und keine Lust habe am Anfang anzufangen) gebe ich dir einfach mal einen Link an die Hand der hoffentlich beim Verständis der Thematik hilft:
http://stackoverflow.com/questions/10042/how-do-i-create-a-linked-list-data-structure-in-java

In der ersten Antwort des letzten Links findest du ein funktionierendes Beispiel -vergleiche es mit deinem eigenen. Dann siehst du die Unterschiede. Bezüglich der Fehlermeldung die du gepostet hast - die Fehlermeldung ist eigentlich ziemlich eindeutig -du hast nicht alle Stellen in deinem Code korrigiert. Du solltest dir über die Methodenrümpfe klar werden -also wie diese definiert sind (siehe zweiter Link) -und warum das so ist.

-wenn du konkrette Fragen/Probleme hast schreib einfach nochmal.

Gruß Zoldyck
 
Ok, ich schaus mir mal an.
Aber wir sollen wirklich kein Interface oder den Iterator implementieren...:/
 
Was du da hast sieht erstmal nach der richtigen Richtung aus. Falls das nicht von der Aufgabenstellung gefordert ist, würde ich dir empfehlen, sowohl ende als auch vorgaengerZeiger zu entfernen. Für eine einfach verkettete Liste brauchst du beide nicht, die machen es also fürs erste nur unnötig kompliziert (wenn es dann funktioniert, kannst du die wieder einführen, das macht ein paar Operationen schneller, aber konzentrier dich erstmal auf das Grundlegende).
Dein append-Methode ist fehlerhaft wie du schon erkannt hast. Ich muss leider zugeben, dass ich den else-Teil nicht wirklich verstehe. Ich vermute du hast da schon einiges dran rumgebastelt, irgendwann dann vielleicht auch auf gut Glück(?) :).
Der if-Teil stimmt aber fast, du must allerdings auch das ende auf die einzufügende Node setzen, denn wenn eine Liste genau ein Element enthält ist anfang = node = ende. Wie oben gesagt solltest du es aber erstmal ohne ende versuchen. Dann musst du nur das letzte Element in der Liste suchen und seinen next-Pointer auf das einzufügende Element zeigen.

Das List interface würde ich zunächst nicht angehen, das ist zwar allgemein eine gute Idee, zunächst solltest du aber die Liste verstehen und die grundlegenden Operationen implementieren.

Falls du Probleme hast, dir das vorzustellen male dir die Liste auf, wie sie vor und nach den Operationen aussehen soll, also zB so:
Code:
[1->2->3->] -- append(4) --> [1->2->3->4->]
und überlege dir, welche einzelnen Schritte du dafür brauchst.
Lass dich nicht entmutigen und viel Erfolg!

EDIT: Und bitte schreib code auf Englisch! Früher oder später musst du das ohnehin machen, also fang lieber jetzt damit an (Falls dein Prof das auf Deutsch erwartet würde ich mich beschweren gehen ;))
 
Zuletzt bearbeitet:
Ich schaue es mir jetzt nochmal an.
Jedenfalls müssen wir auch ende und vorgaengerZeiger implementieren...
 
Ich würde die trotzdem erstmal weglassen, die nachträglich einzubauen ist leichter und hilft imho dem Verständnis mehr.
 
Zurück
Oben