Linked list, Methode zum Vertauschen von Elementen

Hallo zusammen!
Ich habe eine doppelt verkettete Liste implementiert. Ich mache das als Übung für mich, dementsprechend habe ich keine Fehlereingaben etc. berücksichtigt. Und habe nun aber das Problem mit der Methode swap(). Sie soll zwei Elemente vertauschen und als Parameter bekommt sie die Positionen der Elemente. Mit der Methode isThere() finde ich nach vorgegebener Position das entsprechende Element. Also bei Testausgaben in der Methode swap() passt alles die Elemente sind so wie sein sollen jeweils das nächste und auch nach dem Vertauschen. Die Listenausgabe nach dem Vertauschen stimmt aber nicht. Weiß jemand vllt wo der Fehler liegen könnte? Vielen Dank, da ist der ganze Code:

Java:
class Element{



Element prev;

Element next;

String daten;



Element (Element prev, Element next, String daten){



this.prev=prev;

this.next=next;

this.daten=daten;

}



void setPrev(Element prev){

this.prev=prev;

}



void setNext(Element next){

this.next=next;

}



Element getPrev(){

return this.prev;

}



Element getNext(){

return this.next;

}



void setDaten(String daten){



this.daten=daten;

}



String getDaten(){



return this.daten;



}

}











public class List {



Element first=null;

Element last=null;

Element curr=null;



void insert(String daten){



if(first==null){

first=new Element(null,null,daten);

curr=first;

}else if(curr.getNext()==null){



last=new Element(curr,null,daten);

curr.setNext(last);

curr=last;

}

}



void insertAtBefore(int pos, String daten){

int i=1;

Element pivot=first;

while(i<=pos&&pivot!=null){



if(i==pos&&pivot.getPrev()==null){

curr=new Element(null,pivot,daten);

pivot.setPrev(curr);

first=curr;

}else

if (i==pos){

curr=new Element(pivot.getPrev(),pivot,daten);

Element pivotVor=pivot.getPrev();

pivotVor.setNext(curr);

pivot.setPrev(curr);

}



i++;

pivot=pivot.getNext();



}

}



void insertAtAfter(int pos, String daten){

int i=1;

Element pivot=first;

while(i<=pos&&pivot!=null){



if(i==pos&&pivot.getNext()==null){

curr=new Element(pivot,null,daten);

pivot.setNext(curr);

last=curr;

}else

if (i==pos){

curr=new Element(pivot,pivot.getNext(),daten);

Element pivotNext=pivot.getNext();

pivotNext.setPrev(curr);

pivot.setNext(curr);



}

i++;

pivot=pivot.getNext();

}

}



void delete(int pos){

int i=1;

Element pivot=first;

while(i<=pos&&pivot!=null){

if(i==pos){

Element prevP=pivot.getPrev();

Element nextP=pivot.getNext();

prevP.setNext(nextP);

nextP.setPrev(prevP);

pivot.daten=null;

}

i++;

pivot=pivot.getNext();

}

}



int length(){

int length=0;

curr=first;

while(curr!=null){

curr=curr.getNext();

length++;

}

return length;

}



Element isThere(int pos){

int i=1;

Element pivot=first;

int max=length();

while(i<=max){

if(i==pos)

break;

i++;

pivot=pivot.getNext();

}

return pivot;

}



void showElement(int pos){



curr=isThere(pos);

if(curr!=null)

System.out.println("Das Element hat daten: "+curr.getDaten());

else

System.out.println("Nema go");



}



void swap(int pos1, int pos2){



Element swap1=isThere(pos1);

//System.out.println(swap1.getPrev().daten);

Element swap2=isThere(pos2);



curr=swap1;



curr.setDaten(swap1.getDaten());

curr.setNext(swap1.getNext());

curr.setPrev(swap1.getPrev());

//swap1.daten=swap2.daten;

swap1=swap2;

//System.out.println(swap1.daten);

swap1.setDaten(swap2.getDaten());

swap1.setNext(swap2.getNext());

swap1.setPrev(swap2.getPrev());



swap2=curr;

swap2.setDaten(curr.getDaten());

swap2.setNext(curr.getNext());

swap2.setPrev(curr.getPrev());

//System.out.println(swap1.getPrev().daten);

}



void ausgabe(){



curr=first;



while(curr!=null){

System.out.println(curr.daten);

curr=curr.getNext();



}

System.out.println();

}

void rueckAusgabe(){



curr=last;

while(curr!=null){

System.out.println(curr.daten);

curr=curr.getPrev();

}

System.out.println();

}





 public static void main(String[] args)

 {

 

 List l=new List();

 for (int i=1; i<8; i++){

 l.insert("Element "+i);

 }

 //l.ausgabe();

// l.rueckAusgabe();

 //l.insertAtBefore(1,"Element proba");

 //l.ausgabe();

 //l.rueckAusgabe();

 //l.insertAtAfter(8,"Element proba2");

 //l.delete(3);

 //l.ausgabe();

 //l.rueckAusgabe();

 //l.showElement(3);

 l.swap(2,3);

 l.ausgabe();

 l.rueckAusgabe();

 }



}
 
Wozu braucht man denn bitte eine "current" Variable in einer Liste? Was soll die denn tun?
Das sieht fast so aus, als wäre das einfach nur eine Hilfsvariable, die du in den Methoden verwendest. Du solltest diese dann aber auch nur in den Methoden deklarieren.
Und lerne bitte den Keyboard-Shortcut für "Quellcode formatieren" in deiner IDE...
 
Ja es ist compiler für Handy. Stimmt es ist Hilfsvariable, werde ich bearbeiten.

Wozu braucht man denn bitte eine "current" Variable in einer Liste? Was soll die denn tun?
Das sieht fast so aus, als wäre das einfach nur eine Hilfsvariable, die du in den Methoden verwendest. Du solltest diese dann aber auch nur in den Methoden deklarieren.
Und lerne bitte den Keyboard-Shortcut für "Quellcode formatieren" in deiner IDE...
 
Ich würde einfach die Daten tauschen statt mit Referenzen herumzuhantieren. Also, finde beide Elemente, tausche e1.data und e2.data. Fertig.
 
Ich würde einfach die Daten tauschen statt mit Referenzen herumzuhantieren. Also, finde beide Elemente, tausche e1.data und e2.data. Fertig.
Ja das dachte ich mir auch, wollte aber hinkriegen, dass ich die Elemente selber tausche. Setten ist auch eigentlich nicht notwendig, da die Referenzen auf next, prev beibehalten bleiben, habe ich in dem Fall aus Sicherheit noch mal ausprobiert
 
Zuletzt bearbeitet:
Wenn du die Elemente selbst tauschen/umhängen willst, dann so:
Java:
  void swap(int pos1, int pos2) {
    Element swap1 = isThere(pos1);
    Element swap2 = isThere(pos2);
    if (swap1.prev != null)
      swap1.prev.next = swap2;
    if (swap2.prev != null)
      swap2.prev.next = swap1;
    if (swap1.next != null)
      swap1.next.prev = swap2;
    if (swap2.next != null)
      swap2.next.prev = swap1;
    Element e = swap1.prev;
    swap1.prev = swap2.prev;
    swap2.prev = e;
    e = swap1.next;
    swap1.next = swap2.next;
    swap2.next = e;
  }
 
Ja genau ! Vielen Dank ! Das macht Sinn. Bei der Rückwärtsausgabe allerdings kriege ich reached end while parsing Fehler
 
Dann ist entweder die von dir genutzte IDE totaler Schrott oder du hast einen Syntaxfehler irgendwo. Ich nehme mal an, dass es ein Compilerfehler und kein Laufzeitfehler ist.
 
Also ich bekomme am Rechner bei Rückwärtsausgabe eine endlose Schleife auf swap1, also das erste Element, das auszutauschen ist. Kann es sein, dass es auf sich selbst zeigt irgendwo? Ich sehe das nicht
 
Java:
if(curr.prev.daten==curr.daten)
break;
so lässt sich die endlose Rückwärtsausgabeschleife bremsen in der Methode rueckAusgabe(). Also der Handycompiler war nicht Schuld ;)
 
Ich hab den Fehler gefunden. Wenn man zwei benachbarte Elemente vertauschen will, dann zeigt das zweite bei Rückwärtsausgabe immer auf sich selbst..
 
Java:
swap1.prev.next=swap2;
swap2.prev.next=swap1;

Element e=swap1.prev;
swap1.prev=swap2.prev;
swap2.prev=e;

swap1.next.prev=swap2;
swap2.next.prev=swap1;

e = swap1.next;
swap1.next=swap2.next;
swap2.next=e;
Das ist jetzt der funktionierende Code. Man soll es richtungsweise machen, weil sonst sich die Referenzen in einer der Richtungen überschneiden wenn man zwei benachbarte Elemente vertauschen möchte. Der Fall, dass swap1 first bzw. swap2 last ist, ist jetzt hier nicht berücksichtigt. Danke für die Hilfe !
 
Passende Stellenanzeigen aus deiner Region:

Neue Themen

Oben