Iterate durch eine verknüpfte Liste in Java beim Filtern direkt in der nächsten() Methode?

Question

Ich habe ein Problem mit einem Teil meiner Hausaufgaben für CS. Ich muss eine verknüpfte Liste in Java schreiben und dann nur die ungeraden Zahlen mit einem Iterator wiederholen. Im Wesentlichen muss eine ForEach-Schleife nur durch ungerade Zahlen durchlaufen.

Bisher habe ich dies nur in meiner Klasse LinkedList:

public class Iterator implements java.util.Iterator<Integer> { 

    private Node nextNode; 

    public Iterator(){ 
     nextNode = head_; 
    } 

    @Override 
    public boolean hasNext() { 
     return (nextNode != null);// && (nextNode.data_ % 2 != 0); 
    } 

    @Override 
    public Integer next() { 
     if (!hasNext()) throw new NoSuchElementException(); 
     Integer data = nextNode.data_; 
     nextNode = nextNode.next_; 
     return data; 
    } 

    public void remove(){ 
     throw new UnsupportedOperationException(); 
    } 
} 

public Iterator iterator() { 
    return new Iterator(); 
} 

Wenn ich Kommentar- && (nextNode.data_ % 2 != 0);, dann wird nur die erste Zahl (die unebene werden passiert) gedruckt wird. Ich habe auch versucht, dies in der nächsten() Methode zu implementieren, aber ohne Erfolg.

Bitte geben Sie mir einen Tipp, was Sie weiter versuchen sollten.

// Spätere Bearbeitung: Ich habe nicht erwähnt, dass die verknüpfte Liste, die ich filtern möchte, aus Zufallszahlen besteht und nicht sortiert ist.

Answer 1

Wir in der offiziellen Dokumentation für Iterator.hasNext und Iterator.next

http://docs.oracle.com/javase/8/docs/api/java/util/Iterator.html

Für hasNext aussehen sollte lesen wir

Gibt true zurück, wenn die Iteration hat mehr Elemente

Die interne Struktur spielt keine Rolle. Also haben wir keine Wahl, unsere Implementierung muss die gesamte verknüpfte Liste überprüfen, bis sie entweder ein ungerades Element oder das Ende der Liste findet. Beachten Sie auch, dass ein Anruf von Ihre Struktur nicht ändern sollte.

public boolean hasNext() { 
     Node tempNode = nextNode; // nextNode need to stay the same 
     while (tempNode != null){ 
      if (tempNode .data_ % 2 != 0){ 
       return true; 
      } 
      tempNode = tempNode._next; 
     } 
     // if we are here, we found no element that is odd 
     return false; 
    } 

Nun ist die next Methode ist fast das gleiche, diesmal müssen wir die interne nextNode vorzurücken. Wenn wir es nicht tun, erhält der Aufrufer immer das gleiche Element.

public Integer next() { 
    while (nextNode != null){ 
      int data = nextNode.data; 
      nextNode = nextNode.next_; 
      if (data % 2 != 0){ 
       return data; 
      } 
    } 
    //no odd element was found 
    throw new NoSuchElementException(); 
} 

Answer 2

Ihr Filter sollte sich innerhalb Ihrer .next Methode befinden, nicht .hasNext. Dies ist eine einfache Logik: Sie durchlaufen die gesamte Liste und muss true alle Zeiten zurückgeben, außer wenn das aktuelle Element das letzte ist.

Answer 3

Sie müssen nextnode.next_ zweimal verwenden, um nur die ungeraden Zahlen zu erhalten. Dies liegt daran, dass Sie nextnode.next_ überspringen möchten, da dies immer eine gerade Zahl wäre, wenn Ihre aktuelle ungerade Zahl ist. Außerdem muss Ihr hasnext zwei Leerzeichen voraus überprüfen

Answer 4

Edit: Dies sollte der Weg sein, es zu tun, wenn Sie nur ungerade Datenpunkte wollen. Ich nehme an, wir gingen davon aus, dass Sie mit ungeraden Indizes beginnen wollten.

@Override 
public Integer next() { 
    //keep looking for an odd element as long as there is a next 
    while (hasNext()) { 

    //move to the next node 
    nextNode = nextNode.next_; 

    //check for an odd data point 
    if (nextNode.data_ % 2 == 1) { 

     //and return it 
     return data; 
    } 
    } 

    //no odd element was found 
    throw new NoSuchElementException(); 
}