Personalizado de la lista enlazada tener elementos no deseados

Question

He hecho una costumbre lista enlazada de nodos y clases para la escuela y me he decidido a practicar cómo utilizar mediante la realización de un texto de girar como un juego

En mi lista enlazada clase, tengo una travesía método que imprime la palabra y por cuánto tiempo la palabra es en la consola.

El código que tengo hasta ahora es este:

MyLinkedList.java

package game;

public class MyLinkedList {
    public int counter;
    public MyNode head;
    public MyNode tail;

    public MyLinkedList() {
        counter = 0;
    }

    public void InsertToHead(MyNode m) {
        if (counter == 0) {
            head = tail = m;
        } else {
            m.setNext(head);
            head.setPrev(m);
            head = m;
        }
        counter++;
    }

    public int size() {
        return counter;
    }

    public boolean isEmpty() {
        if (counter == 0) {
            return true;
        } else {
            return false;
        }
    }

    public MyNode retrieveWord(String s) {
        MyNode n = head;
        while (n.next != null) {
            if (s.equals(n.getWord())) {
                return n;
            } else {
                n = n.next;
            }
        }
        if (s.equals(tail.getWord())) {
            return tail;
        }
        return null;
    }

    public MyNode retrieveLength(int l) {
        MyNode n = head;
        while (n.next != null) {
            if (l == n.getLength()) {
                return n;
            } else {
                n = n.next;
            }
        }
        if (l == tail.getLength()) {
            return tail;
        }
        return null;
    }

    public void traverse() {
        MyNode n = head;
        if (head != null) {
            while (n.next != null) {
                System.out.println(n.getWord() + "\t" + n.getLength());
                n = n.next;
            }
            System.out.println(tail.getWord() + "\t" + n.getLength());
        }
    }
}

MyNode.java

package game;

public class MyNode {

    public String word;
    public int length;
    public MyNode next, previous;

    public MyNode() {
        word = null;
        length = 0;
        next = null;
        previous = null;
    }

    public MyNode(String w, int l) {
        word = w;
        length = l;
        next = null;
        previous = null;
    }

    public void setNext(MyNode n) {
        next = n;
    }

    public void setPrev(MyNode n) {
        previous = n;
    }

    public void toHead(MyNode n){
        while(n.previous != null){
            n.setPrev(n);
        }
    }
    public void setWord(String w){
        word = w;
    }
    public String getWord(){
        return word;    
    }
    public void setLength(int l){
        length = l;
    }
    public int getLength(){
        return length;
    }
    public boolean hasNext(){
        return next != null;
    }
}

WordSort.java

package game;

import java.io.File;
import java.io.FileNotFoundException;
import java.util.Scanner;

public class WordSort {
Scanner wordScan;

public WordSort() {
    MyLinkedList sixLetters = new MyLinkedList();
    MyLinkedList fiveLetters = new MyLinkedList();
    MyLinkedList fourLetters = new MyLinkedList();
    MyLinkedList threeLetters = new MyLinkedList();
    MyLinkedList rejects = new MyLinkedList();
    try {
        wordScan = new Scanner(new File("corncob_lowercase.txt"));
        wordScan.useDelimiter("\r\n");
        MyLinkedList ll = new MyLinkedList();
        while (wordScan.hasNext()) {
            String temp = wordScan.next();
            MyNode node = new MyNode();
            node.setWord(temp);
            node.setLength(temp.length());
            ll.InsertToHead(node);
            if (temp.length() == 6) {
                sixLetters.InsertToHead(node);
            } else if (temp.length() == 5) {
                fiveLetters.InsertToHead(node);
            } else if (temp.length() == 4) {
                fourLetters.InsertToHead(node);
            } else if (temp.length() == 3) {
                threeLetters.InsertToHead(node);
            } else {
                rejects.InsertToHead(node);
            }
        }
        wordScan.close();
        threeLetters.traverse();
    } catch (FileNotFoundException e) {
        // TODO Auto-generated catch block
        System.out.println("Missing File: corncob_lowercase.txt");
    }
}
}

y por último, Driver.java

package game;

import javax.swing.JFrame;
import javax.swing.JPanel;

public class Driver extends JPanel {
private static final long serialVersionUID = 1L;

public Driver() {
    new WordSort();
}

public static void main(String[] args) {
    JFrame frame = new JFrame("Hidden Word");
    frame.setSize(500, 500);
    frame.setLocationRelativeTo(null);
    frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
    frame.setContentPane(new Driver());
    frame.setVisible(true);
}
}

Cada vez que ejecuto este código, todas las listas enlazadas (threeLetters, fourLetters, fiveLetters, y sixLetters) son completamente bien hasta el final, cuando threeLetters.traverse() se llama, me da esta salida (sólo la parte final)

act 3
ace 3
aby 3
abe 3
abducts 7
abductors   9
abductor    8
abductions  10
abduction   9
abducting   9
abducted    8
abdominal   9
abdomens    8
abdomen 7
abdication  10
abdicating  10
abdicates   9
abdicated   9
abdicate    8
abbreviations   13
abbreviation    12
abbreviating    12
abbreviates 11
abbreviated 11
abbreviate  10
abattoirs   9
abattoir    8
abatement   9
abashed 7
abasement   9
abandons    8
abandonment 11
abandoned   9
abandon 7
abalone 7
aardwolf    8
abe 8

Me parece que no puede averiguar por qué ocurre, pero parece que la impresión fuera todo después de abe y se imprime abe dos veces, una vez con ella registrarse como 3 cartas y una vez como 8 letras de largo!

Tengo el archivo de texto desde este sitio web:

http://www.mieliestronk.com/corncob_lowercase.txt

Answer 1

El problema aquí es sobre todo de diseño.El defecto principal:intentar utilizar una instancia de MyNode en varias listas enlazadas.

Cuando InsertToHead(node) se está modificando el contenido de node sí, específicamente de la cabeza y el próximo referencias.

Revisión:Simple declarar una new MyNode para cada LinkedList que usted quiere usar.En su proyecto específicamente está utilizando dos para cualquier nodo dado. ll y uno de los <inset_number>Letters las listas.Para declarar una nueva MyNode para cada lista:

...
while (wordScan.hasNext()) {
    String temp = wordScan.next();
    MyNode node = new MyNode();
    MyNode node2 = new MyNode();
    node.setWord(temp);
    node2.setWord(temp);
    node.setLength(temp.length());
    node2.setLength(temp.length());
    ll.InsertToHead(node2);
...

Que debería solucionar el problema.

Si quieres saber por QUÉ estaba ocurriendo.Traza el código.Tiene que ver con el intento de agregar nodos a los que ya tienen algunos nodos más conectados en una lista.

Notas Adicionales:

• Intente su mejor para evitar public los campos a menos que usted esté SEGURO de que desea de ellos.I. E.en MyLinkedList alguien utilizando su clase no debería ser capaz de acceder (o incluso ver!) el counter, head o tail, de modo que los que deben realizarse private.Si usted realmente desea tener acceso a ellos, crear get y set métodos

• Su anidada si el bloque en WordSort es un lugar perfecto para una interruptor de como este:

      switch(temp.length()) {
      case 6:
          sixLetters.InsertToHead(node);
          break;
      case 5:
          fiveLetters.InsertToHead(node);
          break;
      case 4:
          fourLetters.InsertToHead(node);
          break;
      case 3:
          threeLetters.InsertToHead(node);
          break;
      default:
          rejects.InsertToHead(node);
          break;              
      }
  

• MyNode funciona bien como una clase separada.Sin embargo, yo muchas veces elegir implementar una clase simple como un nodo como un clase anidada.Esto puede hacer que para algunos muy limpio código.¡Pruébelo!

• Ser cuidadoso a la hora de diseñar sus clases.Hay un montón de métodos adicionales en su diseño.Puede ser fácil de dar vueltas por delante la creación de métodos que usted puede o no utilizar jamás.Me gusta sólo para crear métodos cuando veo que necesito en una clase que utiliza la clase en cuestión.

Feliz Codificación!