Rekursion und Reverse Rekursion durchschleifen hasNext() Methode

Question

Hallo allerseits Ich bin neu in Java, also ich schätze wirklich jede Hilfe zu diesem Thema. Ok also Hier ist das Problem, das ich angetroffen habe: Ich habe eine List-Klasse und eine ListNode-Klasse, Die Liste Klasse wird durch einen Namen, einen FirstNode und einen LastNode dargestellt. firstNode und lastNode stammen vom Typ listNode, ein listNode wird von einem Object (z. B. Daten oder Objekt o) und einem nextNode repräsentiert, der auf den nächsten Knoten in der Liste verweist, der ebenfalls vom Typ listNode ist.

List-Klasse:

public class List { 

private ListNode firstNode; 
private ListNode lastNode; 
private String name; 

public List() { 
    this("list"); 
} 

public List(String listName) { 
    name = listName; 
    firstNode = lastNode = null; 
} 

public void insertAtFront(Object insertItem) { 
    if (isEmpty()) 
     firstNode = lastNode = new ListNode(insertItem); 
    else 
     firstNode = new ListNode(insertItem, firstNode); 
} 

public void insertAtBack(Object insertItem) { 
    if (isEmpty()) 
     firstNode = lastNode = new ListNode(insertItem); 
    else 
     lastNode = lastNode.nextNode = new ListNode(insertItem); 
} 

public Object removeFromFront() throws EmptyListException { 
    if (isEmpty()) 
     throw new EmptyListException(name); 
    Object removedItem = firstNode.data; 

    if (firstNode == lastNode) 
     firstNode = lastNode = null; 
    else 
     firstNode = firstNode.nextNode; 
    return removedItem; 
} 

public Object removeFromBack() throws EmptyListException { 
    if (isEmpty()) 
     throw new EmptyListException(name); 

    Object removedItem = lastNode.data; 
    if (firstNode == lastNode) 
     firstNode = lastNode = null; 
    else { 
     ListNode current = firstNode; 

     while (current.nextNode != lastNode) 
      current = current.nextNode; 

     lastNode = current; 
     current.nextNode = null; 
    } 
    return removedItem; 
} 

public boolean isEmpty() { 
    return firstNode == null; 
} 

public void print() { 
    if (isEmpty()) { 
     System.out.printf("Empty %s\n", name); 
     return; 
    } 
    System.out.printf("The %s is : ", name); 
    ListNode current = firstNode; 

    while (current != null) { 
     System.out.printf("%s", current.data); 
     current = current.nextNode; 
    } 
    System.out.println("\n"); 
} 

@Override 
public String toString() { 
    String stk = "("; 
    if(isEmpty())return "Empty List"; 
    ListNode checkNode = firstNode; 
     while (checkNode != null) { 
     stk += checkNode.data.toString()+ " , "; 
     checkNode = checkNode.nextNode; 
    } 
    return stk+")"; 
} 
public ListNode removeAt (int k){ 
    if(k<=0 || k>getLength()) 
     try{ 
      throw new IllegalValues(); 
     }catch(IllegalValues iv){ 
      iv.printStackTrace(); 
      return null; 
     } 
    ListNode newNode = firstNode; 
    if (k==1) { 
     ListNode removedNode = firstNode; 
     firstNode = firstNode.nextNode; 
     return removedNode; 
    } 
    ListNode someNode = firstNode; 
    for (int i = 1; i < k - 1; i++) { 
     someNode = someNode.nextNode; 
    } 
    ListNode removedNode = someNode.nextNode; 
    someNode.nextNode = someNode.nextNode.nextNode; 
    return removedNode; 
} 
public int getLength(){ 
    ListNode checkNode = firstNode; 
    int count =0; 
    while (checkNode != null) { 
    count++; 
    checkNode = checkNode.nextNode; 
} 
    return count; 
} 
public void show(){ 
    if (firstNode==null) 
     return; 
    else 
     System.out.print(firstNode + " ,"); 
     firstNode.show(); 
    } 
public void showRev(){ 
    if (lastNode==null) 
     return; 
    else 
     System.out.println(lastNode + ","); 
     lastNode.showRev(); 
    } 
    } 

ListNode Klasse

public class ListNode { 

Object data; 
ListNode nextNode; 

public ListNode(Object o) { 
    this(o, null); 
} 

public ListNode(Object o, ListNode node) { 
    data = o; 
    nextNode = node; 
} 

public Object getObject() { 
    return data; 
} 

public ListNode getNext(){ 
    return nextNode; 
} 

public ListNode show() { 
if(this.nextNode == null)return this; 
ListNode displayMe = nextNode.show(); 
System.out.print(displayMe + " , "); 
return displayMe; 

} 

public ListNode showRev() { 
    if(this.firstNode == null)return this; 
    ListNode displayMe = lastNode.show(); 
    System.out.print(displayMe + " , "); 
    return displayMe; 

} 

} 

ich eine rekursive Methode namens Show haben, die alle Objekte in der Liste zeigt von Anfang an bis zum Ende jetzt ich versuche, mach etwas Ähnliches (der Methodenname ist showRev()), der die Objekte vom Ende bis zum Anfang anzeigt (eine rekursive Methode) und ich glaube nicht, dass es möglich ist, eine vorherige Methode zu erstellen, also bin ich irgendwie bei dieser Methode festgefahren. Id wirklich zu schätzen irgendwelche Ideen Danke Jungs

Answer 1

Wenn Ihr showRev Methode erlaubt ist, ein Argument zu nehmen, dann können wir jeden ListNode in einem java.util.List speichern:

public java.util.List<ListNode> showRev(java.util.List<ListNode> nodes) { 
    if (this.nextNode == null) { 
     Collections.reverse(nodes); 

     System.out.println(nodes.stream().collect(Collectors.joining(" "))); 

     return nodes; 
    } 

    nodes.add(lastNode.show()); 

    return showRev(nodes); 
} 

Beachten Sie, dass die Rekursion hier tut nichts Besonderes, aber fügen Sie ListNode s zu java.util.List hinzu.

Um diese Methode aufzurufen, übergeben Sie einfach eine new ArrayList<>().

Auch würde ich List als den Namen für eine Klasse verwenden, wie java.util.List kann leicht damit verwechselt werden.