Den Kopf von ListNode in Java verfolgen

Question

Ich arbeite gerade an meiner eigenen Java-Klasse namens LString, die zwischen verknüpften Listen von Zeichen und Strings hin und her konvertieren soll.

Ich habe Probleme mit meiner ToString() -Methode, insbesondere verfolgen den "Kopf" der verknüpften Liste, um es durchlaufen und verketten die Zeichen in eine neue Zeichenfolge. Während ich recherchiere, lese ich, dass ich irgendwie den Kopf der Liste verfolgen soll, aber ich kann nicht herausfinden, wie ich es umsetzen soll.

Jede Hilfe würde sehr geschätzt werden!

Edit: Die Fehlermeldung Ich erhalte ist:

LString.java:79: Fehler: kann nicht Symbol
ListNode current = this.front finden;

public class LString{ 


    private static int length; 
    // ListNode constructors 

    // Creates a new ListNode with characters stored in variable "data" and 
    // Node named next 
    private class ListNode{ 
     char item; 
     ListNode next; 


     private ListNode(){ 
     } 

     // creates a new ListNode that has the value and links to the specified ListNode 
     private ListNode(char item, ListNode next){ 
     this.item = item; 
     this.next = next; 
     } 

     // given a character, creates a new ListNode that doesn't link to anything 
     private ListNode(char item){ 
     this.item = item; 
     this.next = null; 
     } 


    } 


    public LString(){ 
     this.length = 0; 
     ListNode front = new ListNode(); 
    } 

    //LString 
    // Takes in a String object and loops until it has added all characters to a new linked list 
    public LString(String original){ 

     ListNode front; 
     this.length = 1;       // length keeps track of number of nodes 

     if (original.charAt(0) == 0){    // creates a new ListNode if it is an empty string 
     front = new ListNode();  
     } 
     else { 
     front = new ListNode(original.charAt(0)); 
     } 


     //System.out.println("this is happening " + front.item); 

     //ListNode current = front; 
     for (int index = 1; index < original.length(); index++) { 
     front.next = new ListNode(original.charAt(index), front.next); 
     front = front.next; 
     //System.out.println("strings: " + front.item); 
     length++; 
     } 
     //System.out.println("length: " + length); 
    } 

    // returns length of the LString object 
    public int length(){ 
     return this.length; 
    } 

    // toString takes an LString object and converts it to a string 
    public String toString(){ 
     StringBuilder newString; 

     ListNode current = this.front; 
     while (current.next != null){ 
     newString.append(current.item); 
     current = current.next; 
     } 

     return newString.toString(); 
    } 

    public static void main(String[] args){ 
     LString stuffTest = new LString("hello"); 
     int valueOf = stuffTest.length(); 
     System.out.println(stuffTest.length()); 
     String testMeWhy = stuffTest.toString(); 

    } 





} 

Answer 1

Das allgemeine Muster eine verknüpfte Liste für den Aufbau von bis zum Ende angehängt ist:

Zu Beginn:

head = null; 
tail = null; 

Um newNode in die Liste anhängen:

if (head == null) { 
    head = newNode; 
} else { 
    tail.next = newNode; 
} 
tail = newNode; 

Ich denke, Sie versuchen, dies zu tun, indem Sie nur einen Zeiger in der List-Klasse, die nicht w Ork sehr gut. Wenn Sie dieses Muster verwenden, bedeutet dies, dass Sie keinen "speziellen" Knoten an der Spitze der Liste haben müssen, es sei denn, es gibt einen anderen guten Grund dafür. Es sieht so aus, als ob Sie versuchen würden, new ListNode() ohne Argumente zu verwenden, um eine Art spezieller Knoten zu erstellen, aber nur manchmal. Es ist unnötig und macht die Dinge nur komplizierter.

Answer 2

Ihr grundlegendes Problem ist, dass es nur einen geben sollte front, und es sollte ein Klassenmitglied und keine lokale Variable sein. So behält Ihre LString Klasse "den ersten Knoten".

public class LString { 
    private ListNode front = null; 
    private int size = 0; 
    ... 

Dies wird Sie starten und Ihnen erlauben, die tatsächliche Liste zu pflegen. Ihre anderen LString Methoden werden auch einige Arbeit benötigen, aber sobald Sie über dieses Problem hinauskommen, sollten Sie Ihren Debugger verwenden können, um durch den Code zu gehen und die verbleibenden Probleme selbst zu lösen.