Doppelt Verkettete Liste

ahretour

Mitglied
Hallo zusammen!

Ich stehe hier gerade vor einem Problem und sitze schon mindestens 5 Stunden daran, komme einfach nicht auf die Lösung. Folgende Aufgabenstellung:

Es muss eine doppelt verkettete Liste implementiert werden, die Knoten speichert. Diese Knoten besitzen ein Datenfeld mit Bestellung und zwei Referenzen. Eine Referenz zeigt auf den vorherigen Knoten, die andere Referenz auf den nächsten Knoten.

Hier dazu die Bestellung-Klasse:
Java:
public class Bestellung {
	private int id = 0;
	private static int counter=0;
	private String bez;
	private int prio;
	
	public Bestellung(String bez, int prio){
		counter++;
		this.id=counter;
		setBez(bez);
		setPrio(prio);
	}
	
	public void setBez(String bez){
		if(bez==null || (bez.length()<3)) throw new RuntimeException("Die Bezeichnung muss mindestens 3 Zeichen enthalten!");
		this.bez=bez;
	}
	
	public void setPrio(int prio){
		if(prio!=0 && prio!=1 && prio!=2) throw new RuntimeException("Die Priorität darf nur 0, 1 und 2 sein!");
		this.prio=prio;
	}
	
	public String getBez(){
		return bez;
	}
	
	public int getId(){
		return id;
	}
	
	public int getPrio(){
		return prio;
	}
	
	@Override
	public String toString(){
		return "Bestellung-ID: " + getId() + 
			   "\nBezeichnung: " +getBez() +
			   "\nPriorität: " +getPrio();
	}
	
	@Override
	public boolean equals(Object o){
		if(o instanceof Bestellung){
			Bestellung b = (Bestellung) o;
			
			return (this.getId() == b.getId());
					
		}
		else return false;
	}
}

Und die Knoten-Klasse:
Java:
public class Knoten {
	private Bestellung b;
	private Knoten vorheriger;
	private Knoten naechster;
	
	private Knoten(){
		
	}
	
	public Knoten(Bestellung best, Knoten next, Knoten prev){
		DoppeltVerketteteListe.anzKnoten++;
		this.setBestellung(best);
		this.setNaechster(next);
		this.setVorheriger(prev);
	}
	

	
	public void setBestellung(Bestellung best){
		b=best;
	}
	
	public Bestellung getBestellung(){
		return b;
	}
	
	public void setVorheriger(Knoten v){
		vorheriger=v;
	}
	
	public void setNaechster(Knoten n){
		naechster=n;
	}
	
	public Knoten getVorheriger(){
		return vorheriger;
	}
	
	public Knoten getNaechster(){
		return naechster;
	}
	
	@Override
	public String toString(){
		if (this.getBestellung()==null) return null;
		return this.getBestellung().toString();
	}
	
	

}

Und die implementierung der doppelt verketteten Liste:
Java:
public class DoppeltVerketteteListe {
	private Knoten wurzel;
	private Knoten ende;
	public static int anzKnoten;
	
	public DoppeltVerketteteListe(Bestellung b){
		wurzel=new Knoten(b, ende, null);
                ende=new Knoten(b, null, wurzel);
		anzKnoten--;
	}
	
	public Bestellung getFirst(){
		if(wurzel==null) return null;
		return wurzel.getBestellung();
	}
	
	public Bestellung getLast(){
		if(wurzel==null) return null;
		Knoten k=wurzel;
		for(int i=1; i<=anzKnoten; i++){
			if(k.getNaechster()!=null)
			k=k.getNaechster();
		}
		return k.getBestellung();
	}
	
	public Bestellung get(int pos){
		
		if((pos<1) || (pos>anzKnoten)) throw new RuntimeException("Die Position ist inkorrekt!");
		
		Knoten k=wurzel;
		
		for(int i=1; i<pos; i++){
			k=k.getNaechster();
		}
		
		return k.getBestellung();
	}
	
	
	public String getAllData(){
		String ausgabe;
		if(anzKnoten==0) return "Es sind keine Knoten erstellt worden!";
		Knoten k=wurzel;
		ausgabe=k.getBestellung().toString();
		ausgabe+="\n-----------------------\n";
		while(k.getNaechster()!=null){
			k=k.getNaechster();
			ausgabe+=k.getBestellung().toString();
			ausgabe+="\n-----------------------\n";
		}
		return ausgabe;
	}
	
	public void removeFirst(){
		if(wurzel!=null) wurzel=wurzel.getNaechster();
		anzKnoten--;
	}
	
	public void removeLast(){
		if(wurzel==null) return;
		if(wurzel.getNaechster()==null){
			wurzel=null;
		}
		else{
			Knoten k=wurzel;
			Knoten naechster=null;
			Knoten vorheriger=null;
			do{
				naechster=k.getNaechster();
				if(naechster!=null){
					vorheriger=k;
					k=naechster;
				}
			}while(naechster!=null);
			vorheriger.setNaechster(null);
		}
		anzKnoten--;
	}

	public void remove(int pos){
		int anz=anzKnoten;
		if((pos<1) || (pos>anz)) throw new RuntimeException("Die Position ist inkorrekt!");
		if(pos==1){
			this.removeFirst(); return;
		}
		if(pos==anz){
			this.removeLast(); return;
		}
		
		Knoten k=wurzel;
		Knoten naechster=null;
		Knoten vorheriger=null;
		for (int i=1; i<pos; i++){
			vorheriger=k;
			k=k.getNaechster();
		}
		naechster=k.getNaechster();
		vorheriger.setNaechster(naechster);
	}
	
	public void add(int pos, Bestellung best){
		if((pos<1) || (pos>anzKnoten)) throw new RuntimeException("Die Position ist inkorrekt!");
		if(pos==1){
			this.addFirst(best); return;
		}
		if(pos==anzKnoten){
			this.addLast(best); return;
		}
		Knoten k=wurzel;
		
		for(int i=1; i<pos; i++){
			if(k.getNaechster()!=null) k=k.getNaechster();
		}
		
		
		Knoten neu=new Knoten(best, k, k.getVorheriger());
		k.getVorheriger().setNaechster(neu);
		k.setVorheriger(neu);
	}
	
	public void addFirst(Bestellung best){
		Knoten k = new Knoten(best, wurzel, null);
		wurzel=k;
	}
	
	public void addLast(Bestellung best){
		Knoten k=wurzel;
		Knoten vorheriger;
		Knoten naechster;
		do{
			naechster=k.getNaechster();
			vorheriger=k.getVorheriger();
			if(naechster!=null) k=k.getNaechster();
		}while(naechster!=null);
		naechster=new Knoten(best, k.getNaechster(), k.getVorheriger());
		k.setNaechster(naechster);
		k.setVorheriger(vorheriger);
	}
	
}

Wenn ich nun versuche die Methode add() zu verwenden, bekomme ich folgene Fehlermeldung:
Java:
Exception in thread "main" java.lang.NullPointerException
	at listen.DoppeltVerketteteListe.add(DoppeltVerketteteListe.java:120)
	at listen.TestListe.main(TestListe.java:18)

Dazu die Zeile 120:
Java:
k.getVorheriger().setNaechster(neu);

Mir ist bewusst, dass die Referenz auf den vorherigen Knoten irgendwie nicht stimmt. Blos weiß ich nicht wie ich das lösen kann.

Hoffe das macht nicht zu große Arbeit :oops:
MfG ahretour
 
S

SlaterB

Gast
die main-Methode mit der Einfügereihenfolge,
überhaupt das Wissen wieviele Elemente vorhanden sind, welcher Index bei add verwendet wird,
das hältst du alles für unwichtig während du die Bestellung-Klasse postest? hmm

----

der Fehler ist klar, getVorheriger() wird wohl null zurückliefern,
jetzt kannst du
a) überlegen, ob es in dieser Situation ansichts des Aufbaus der Gesamtliste/ Vergleich mit deinem Nachvollziehen auf Papier ok ist,
dass der Vorgänger null ist, wenn ja musst du den Code anpassen so dass dies berücksichtigt wird, dürfte klar sein
b) wenn getVorheriger() nicht null sein darf, dann an dieser Stelle vor der Exception die gesamte Liste ausgeben, alle Elemente mit allen Links nach vorne und nach hinten,
gegebenenfalls auch schon einige Schritte vorher,
zurückgehen zu einer Situation die korrekt ist und den ersten Fehlerschritt herausfinden

Verfahren für alle Programme anwendbar, deren Durchlauf immer gleich ist, auf Papier vorher schon durchgespielt werden kann ;)
 
H

hüteüberhüte

Gast
Also ganz kurz, du brauchst so etwas wie den Kopf deiner Liste. Wenn der Kopf null ist, ist das einzufügende Element der Kopf. Wenn er nicht null ist, dann musst du die Liste durchgehen bis zu dem Element, dessen Nachfolger null ist und an dieser Stelle einfügen. Man kann sich auch Anfang und Ende der Liste merken, um das Einfügen zu beschleunigen. Die Verkettung (die Referenzen auf Vorgänger und Nachfolger) sind beim Einfügen und Entfernen entsprechend zu setzen...
 

ahretour

Mitglied
Danke erstmal für die schnelle Antwort!

Hier dazu die Main-Methode:
Java:
public class TestListe {

	
	public static void main(String[] args) {
		Bestellung b1=new Bestellung("Hammer", 1);
		Bestellung b2=new Bestellung("Schraube", 2);
		Bestellung b3=new Bestellung("Eisen", 0);
		Bestellung b4=new Bestellung("Eisen", 0);
		Bestellung b5=new Bestellung("Magnesium", 2);
		
		DoppeltVerketteteListe d=new DoppeltVerketteteListe(b1);
		d.addFirst(b2);
		d.addLast(b3);
		d.add(2, b5);
		System.out.println(d.getAllData());
       }
}
 
S

SlaterB

Gast
mein Posting enthält die Anleitung zur Lösung,
nur irgendwas zu programmieren ohne sich die Situation im Detail anzuschauen
und evtl. Fehler von anderen ohne Eigenbeteiligung korrigieren zu lassen, ist kein guter Weg
 
H

hüteüberhüte

Gast
Dann musst du einfach nur ein Fallunterscheidung durchführen:

addLast(Elem): Kopf == null => Kopf = Elem; Kopf != null => Nachfolger des letzten Elements Elem, Vorgänger von Elem letztes Element;
addFirst und remove entsprechend...
 

ahretour

Mitglied
@SlaterB

Zu a) Vorheriger darf eigentlich nach der for-Schleife nicht mehr null sein, da ja k immer auf den nächsten Knoten gesetzt wird. deswegen ->

b) ich habe genau das schon ausprobiert.

Zu diesem Zeitpunkt:
Java:
Knoten k=wurzel;
hat k auch einen Nächsten, aber keinen Vorherigen, was auch richtig ist, da meine Wurzel den Kopf der Liste repräsentiert.

nach der Schleife:
Java:
for(int i=1; i<pos; i++){
			if(k.getNaechster()!=null) k=k.getNaechster();
		}

ist k der nächste Knoten, hat aber keinen vorherigen und auch keinen nächsten.
 

ahretour

Mitglied
@HüteÜberHüte

Die Methoden addLast() und addFirst() funktionieren prima. Das einzige Problem liegt in der add()-Methode.

@SlaterB

Ich wollte hier auch von keinen die exakte Lösung als Java-Code sondern einfach nur einen Lösungsvorschlag. Deine Vorschläge sind gut, nur habe ich schon wirklich alles getraced und mir duzent Syso's gemacht um zu überprüfen welcher Knoten gerade wo ist, und welcher der vorherige ist und der nächste.
 
H

hüteüberhüte

Gast
Um ein Element an einer bestimmten Position einzufügen, musst du 4 Referenzen ändern.

Bsp. Einfügen bei 5: Der Nachfolger von 4 ist neues Element, der Vorgänger von 5 ist neues Element, der Nachfolger des neuen Elements ist 5, der Vorgänger des neuen Elements ist 4

Ist ein bisschen fummelig, wenn die Position des einzufügenden Elements die des letzten oder ersten Elements ist
 
S

SlaterB

Gast
> nur habe ich schon wirklich alles getraced und mir duzent Syso's gemacht

so ein Quatsch, mit Verlaub, rein gar nichts hast du angeschaut oder dann zumindest nichts daraus gelernt,
meine Erkenntnisse nun:
am Anfang gibt es wurzel + ende, die nicht verknüpft werden,
(ok, wird vielleicht versucht, aber ende ist noch null als es als Parameter übergeben wird)
da ende nicht weiter benutzt wird spielt das keine große Rolle, ende kann einfach ignoriert werden
ansonsten:
hier schon prüfen, Fehler leicht feststellbar

bei addFirst() setzt du das zweite Element als neue wurzel, die bisherige wurzel wird Nachfolger,
aber bei der bisherigen wurzel wird kein Vorgänger gesetzt
-> das ist dann am Ende die NPE

alles locker leicht zu sehen, nur einen Schritt nach den anderen auch wirklich anschauen
(genau anschauen!, Element, Vorgänger, Nachfolger, der Reihe nach sauber loggen,
dein toString() könnte dafür auch bisschen hilfreicher werden, lieber erstmal den Knoten eindeutige Nummern geben)

Tipp:
in setNaechster(Knoten n) bei n != null dort setVorheriger(this) aufrufen,
dann sparst du dir die Hälfte entsprechender Aufrufe, falls du alle Naechster korrekt setzt

aber nicht gleichzeitig in setVorheriger() auch setNaechster() aufrufen, sonst Endlosschleife zwischen den beiden
 
Zuletzt bearbeitet von einem Moderator:

ahretour

Mitglied
Du hast völlig recht, das wusste ich aber auch. Das Modell an sich ist mir schon klar. Wenn bei der Methode add() die Position 1 ist, oder die Position mit den Anzahl der Knoten übereinstimmt werden auch die Methoden addFirst() und addLast() verwendet.

Schaust du hier:
Java:
public void remove(int pos){
		int anz=anzKnoten;
		if((pos<1) || (pos>anz)) throw new RuntimeException("Die Position ist inkorrekt!");
		if(pos==1){
			this.removeFirst(); return;
		}
		if(pos==anz){
			this.removeLast(); return;
		}


Ich habe in meiner Main-Methode insgesamt 3 Knoten bereits erstellt, bevor ich auf add() zugreife. D.h. die Position von add(2, b5); ist ja eigentlich korrekt.
 

Fant

Bekanntes Mitglied
@HüteÜberHüte

Die Methoden addLast() und addFirst() funktionieren prima. Das einzige Problem liegt in der add()-Methode.

Möglicherweise wird keine Exception geworfen, aber sie machen definitiv nicht das, was sie machen sollen.
Fügst du z.B. in einer leeren Liste ein Element mit addFirst() hinzu, dann ist der Knoten ende immer noch auf null gesetzt. Die Methode addLast dürfte eigentlich auch nicht länger werden, als addFirst. Du kennst doch das ende der Liste. Da musst du nicht erst durch alle Einträge laufen! Und wieso ist überhaupt anzKnoten statisch?
 

ahretour

Mitglied
Die Lösung von SlaterB hat mir geholfen. Ich bin selbst auch schon über das Problem gestoßen, als ich das im Kopf durchgegangen bin, hab es dann aber verworfen, als ich merkte dass addFirst() und addLast() ohne Verbindung mit add() eigentlich wunderbar funktionierten. Deswegen bin ich immer davon ausgegangen, dass die Methode add() irgendwie nicht ganz richtig ist.

@Fant: anzKnoten ist deshalb static, weil die Anzahl selbst nicht in der doppelt verketteten Liste-Klasse erhöht wird, sondern in der Knoten-Klasse im Konstruktor. Das soll ja keine Objekt-Variable sein.
 
S

SlaterB

Gast
aber zwei Listen kannst du so nicht vorhalten, dann müsstest du auch alle Methoden statisch machen,
zählen ist ja ok, aber nicht statisch
 

ahretour

Mitglied
Ja stimmt, das hatte ich garnicht bedacht.

Danke dir nochmals SlaterB! Ich dachte wirklich ich hätte alles überprüft und genau durchgeschaut. Bin eben noch ein Anfänger :oops:
 
H

hüteüberhüte

Gast
Hab das mal eben abgetippt:

Java:
package javaforum;

public class Elem {

    public Object inhalt = null; // sollte eigentlich private sein
    Elem nachfolger = null;
    Elem vorgaenger = null;

    public Elem(Object inhalt) {
        this.inhalt = inhalt;
    }

    @Override
    public String toString() {
        return inhalt.toString();
    }
}
Java:
package javaforum;

public class Liste {

    private Elem kopf = null;

    public void add(int index, Elem elem) throws Exception {
        if (index < 0) {
            throw new Exception("ungültiger Index: " + index);
        }

        if (index == 0) {
            if (kopf == null) {
                kopf = elem;
            } else {
                kopf.vorgaenger = elem;
                elem.nachfolger = kopf;
                kopf = elem;
            }
        } else {
            Elem e = kopf;
            // es soll nach e eingefuegt werden

            for (int i = 1; i < index; i++) {
                if (e.nachfolger == null) {
                    throw new Exception("ungültiger Index: " + index);
                }
                e = e.nachfolger;
            }
            if (e.nachfolger == null) {
                e.nachfolger = elem;
                elem.vorgaenger = e;
            } else {
                elem.vorgaenger = e;
                elem.nachfolger = e.nachfolger;
                elem.vorgaenger.nachfolger = elem;
                elem.nachfolger.vorgaenger = elem;
            }
        }
    }

    @Override
    public String toString() {
        String s = "";

        // Liste vorwaerts
        Elem e = kopf;
        while (e != null) {
            s += e + "; ";
            e = e.nachfolger;
        }

        s += "\n";

        // Liste rueckwaerts
        e = kopf;
        while (e != null && e.nachfolger != null) {
            e = e.nachfolger;
        }
        while (e != null) {
            s += e + "; ";
            e = e.vorgaenger;
        }

        return s;
    }
}
Java:
    public static void main(String[] args) throws Exception {
        Liste l = new Liste();
        System.out.println(l);

        l.add(0, new javaforum.Elem("eins"));
        System.out.println(l);

        l.add(1, new javaforum.Elem("zwei"));
        System.out.println(l);

        l.add(0, new javaforum.Elem("null"));
        System.out.println(l);

        l.add(3, new javaforum.Elem("drei"));
        System.out.println(l);
        
        l.add(3, new javaforum.Elem("zweieinhalb"));
        System.out.println(l);
    }
Code:
-
-
eins; 
eins; 
eins; zwei; 
zwei; eins; 
null; eins; zwei; 
zwei; eins; null; 
null; eins; zwei; drei; 
drei; zwei; eins; null; 
null; eins; zwei; zweieinhalb; drei; 
drei; zweieinhalb; zwei; eins; null;

Funktioniert also ;-) Aber man nuss ein paar Fälle unterscheiden beim Einfügen irgendwo in die Liste
 
Zuletzt bearbeitet von einem Moderator:
Ähnliche Java Themen
  Titel Forum Antworten Datum
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
B Doppelt verkettete Liste implementieren Java Basics - Anfänger-Themen 8
scratchy1 doppelt verkettete Liste testen Java Basics - Anfänger-Themen 8
B Doppelt Verkettete Liste - Ist alles gut so? Java Basics - Anfänger-Themen 3
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
L Doppelt verkettete Liste Java Basics - Anfänger-Themen 6
R doppelt verkettete Liste aus Arrays erstellen Java Basics - Anfänger-Themen 1
S Doppelt verkettete Liste Java Basics - Anfänger-Themen 3
G Doppelt Verkettete Liste Java Basics - Anfänger-Themen 2
E doppelt verkettete liste Java Basics - Anfänger-Themen 10
E Datentypen Doppelt verkettete Liste Java Basics - Anfänger-Themen 10
P Einfügen in doppelt verkettete Liste Java Basics - Anfänger-Themen 7
S Queue als doppelt verkettete Liste Java Basics - Anfänger-Themen 2
N doppelt verkettete liste einfügen Java Basics - Anfänger-Themen 7
K Datentypen Einfach/Doppelt verkettete Liste Java Basics - Anfänger-Themen 4
W Doppelt verkettete Liste implementieren Java Basics - Anfänger-Themen 2
G Doppelt verkettete, generische Liste Java Basics - Anfänger-Themen 11
D doppelt verkettete Liste Java Basics - Anfänger-Themen 16
S Doppelt Verkettete Liste Java Basics - Anfänger-Themen 7
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
B Doppelt verkettete Liste implementieren Java Basics - Anfänger-Themen 12
B Doppelt verkettete Liste Java Basics - Anfänger-Themen 16
R Datentyp Ring - zyklisch doppelt verkettete Liste - HILFE! Java Basics - Anfänger-Themen 12
R doppelt verkettete Liste Java Basics - Anfänger-Themen 8
F doppelt verkettete liste! Java Basics - Anfänger-Themen 8
R doppelt verkettete azyklische Liste Java Basics - Anfänger-Themen 2
T Klasse in Java für doppelt verkettete Listen Java Basics - Anfänger-Themen 4
H Doppelt verkettete Listen Java Basics - Anfänger-Themen 2
S doppelt verkettete Listen Java Basics - Anfänger-Themen 4
X Vererbung: Doppelt verkettete Listen Java Basics - Anfänger-Themen 16
O Doppelt verkette Liste Element löschen Java Basics - Anfänger-Themen 15
J Doppelt verkette Liste ich bitte um Hilfe Java Basics - Anfänger-Themen 4
I Input/Output Code wird doppelt ausgeführt Java Basics - Anfänger-Themen 3
N package wird doppelt im exporer angezeigt Java Basics - Anfänger-Themen 2
L Wie frage ich ab, ob in einem Array, Werte doppelt vorkommen? Java Basics - Anfänger-Themen 4
J Fehler beim generieren von 4 Zufallszahlen Zahl doppelt ist eigentlich ausgeschlossen Java Basics - Anfänger-Themen 9
T Löschen in doppelt verketteter Liste Java Basics - Anfänger-Themen 1
L Input/Output Println wird doppelt ausgeführt Java Basics - Anfänger-Themen 11
D Interface Frame doppelt durch Aufruf der GUI Klasse Java Basics - Anfänger-Themen 1
B BufferedReader gibt Datei-Inhalt doppelt aus Java Basics - Anfänger-Themen 3
M Liste Implementation, doppelt next() Java Basics - Anfänger-Themen 13
D Klassen Doppelt so viele Elemente in Arraylist ? Java Basics - Anfänger-Themen 4
Salo Datentypen "Doppelt" List(e) ("gesucht") Java Basics - Anfänger-Themen 6
L do-while-Schleife läuft doppelt, try catch fehler Java Basics - Anfänger-Themen 12
T Java Methode wird unerwünscht doppelt aufgerufen?! Java Basics - Anfänger-Themen 4
OnDemand Doppelt Werte CSV Java Basics - Anfänger-Themen 2
llabusch Verkette Listen - Einfach und Doppelt Java Basics - Anfänger-Themen 3
N Erste Zeile bei BufferedReader doppelt lesen? Java Basics - Anfänger-Themen 2
E Erste Schritte Sortieren von Objekten in doppelt-verlinkter Liste Java Basics - Anfänger-Themen 9
S Methoden Methode wird doppelt aufgerufen ... Java Basics - Anfänger-Themen 5
J Mehrere Zufallszahlen erzeugen, aber keine darf doppelt erzeugt werden - Wie? Java Basics - Anfänger-Themen 5
B Doppelt gekettete Listen Java Basics - Anfänger-Themen 4
G PropertyChangeListener empfängt Events doppelt Java Basics - Anfänger-Themen 5
L doppelt verkette Liste Java Basics - Anfänger-Themen 5
H Fenster doppelt gezeichnet. Java Basics - Anfänger-Themen 2
G Einfügen aus Zwischenablage - alles doppelt? Java Basics - Anfänger-Themen 2
G JFileChooser kommt doppelt Java Basics - Anfänger-Themen 3
N Nullpointerexception bei Doppelt verketteter Liste Java Basics - Anfänger-Themen 7
M Listen richtig doppelt verkettet? Java Basics - Anfänger-Themen 13
D Exceptions in doppelt verketteter Liste Java Basics - Anfänger-Themen 5
C verify() wird doppelt aufgerufen (JTable + InputVerifier) Java Basics - Anfänger-Themen 8
H doppelt verkette liste Java Basics - Anfänger-Themen 2
L rückwärtsausgeben einer doppelt verketteten liste Java Basics - Anfänger-Themen 2
G JList und ListCellRenderer - Vector erscheint doppelt Java Basics - Anfänger-Themen 6
G JComboBox gibt SelectedItem immer doppelt aus Java Basics - Anfänger-Themen 4
B Array doppelt Felder löschen Java Basics - Anfänger-Themen 27
M Code wird doppelt ausgeführt Java Basics - Anfänger-Themen 2
R Zeilen aus datei lesen + doppelt gespeichert? Java Basics - Anfänger-Themen 3
G Trotz Abfrage immer noch Zahlen doppelt Java Basics - Anfänger-Themen 3
R Benutzerregistrierung: Doppelt registriert. Java Basics - Anfänger-Themen 8
M Verkettete Liste Java Basics - Anfänger-Themen 1
S Einfach-Verkettete-Listen Ausgabe zeigt nur 1. und letzte instanz Java Basics - Anfänger-Themen 2
H Java verkettete Liste, Wert eines Index zurückgeben Java Basics - Anfänger-Themen 1
Igig1 Autoparkplatz verkettete Liste erstes und letztes Auto Java Basics - Anfänger-Themen 13
R Rückgabe: verkettete Liste Java Basics - Anfänger-Themen 2
R einfach verkettete Liste Java Basics - Anfänger-Themen 1
R einfach verkettete Liste Java Basics - Anfänger-Themen 12
B Verkettete Liste durchgehen und einzelne Elemente in neue Liste tun Java Basics - Anfänger-Themen 9
B Bin komplett am verzweifeln :( Verkettete Liste die Objekte hat Attribut auslesen Java Basics - Anfänger-Themen 14
V einfach verkettete Listen Java Basics - Anfänger-Themen 10
A Verkettete Liste Java Basics - Anfänger-Themen 2
L verkettete Liste Java Basics - Anfänger-Themen 15
R Methoden Entferne alle identische Knoten (Typ String) aus verkettete Liste Java Basics - Anfänger-Themen 8
C Methoden Über eine einfach 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 18
K Verkettete Liste und seine Methoden Java Basics - Anfänger-Themen 1
A Was könnten typische Prüfungsaufgaben zum Thema lineare, verkettete Listen sein? Java Basics - Anfänger-Themen 5
N Verkettete Liste implementieren Java Basics - Anfänger-Themen 5
O Einfach verkettete Liste - Revert Methode Java Basics - Anfänger-Themen 1
G Verkettete Liste - Neu erzeugte Elemente werden nicht ausgegeben Java Basics - Anfänger-Themen 5
S Einfach verkettete Liste Element an bestimmter Position einfügen Java Basics - Anfänger-Themen 24
C Verkettete Liste - sortiert einfügen Java Basics - Anfänger-Themen 7
R Erste Schritte Verkettete Liste will einfach nicht in meinen Schädel Java Basics - Anfänger-Themen 11

Ähnliche Java Themen

Neue Themen


Oben