使用列表节点问题中的数据从链接列表中提取值

Question

So what I'm trying to do is extract certain nodes from a linked list based on a value in the LL. (The list class is called WordList) The nodes within the list are called 'Word' and contain the fields "String word","int score", and "Word next"

Running a loop which extracts each Word which has the same score and then saves them to a temp list for further processing as such:

private WordList sortWords(WordList words)
{
      int maxScore = words.getMaxScore(); //returns the maximum score among words int list
      WordList sortedList = new WordList(); //Initializes new WordList with head = null

      WordList temp; //create a new wordList without initializing it.
      Word check; //create a word to iterate through the list
      for (int i=0; i<=maxScore; i++)
      {
           temp = new WordList();
           check = words.head;
           while (check != null)
           {
                  if (check.score == i)
                      temp.addToTail(check);
                  check = check.next;
           }
           //further prcessing
           temp.sortAlphabetically();
           while(!temp.isEmpty())
                sortedList.addToTail(temp.removeFromHead());
       }
}

The list being checked is as follows: (word : score)

january : 14
february : 13
march : 8
april : 8
may : 9
june : 8
july : 11
august : 9
september : 14
october : 12
november : 13
december : 13

I've traced the issue to this point as I'm printing out temp with every iteration. Printing out check.score and i at every iteration revealed that it is definitely checking the correct values as expected. and the first output for temp is expected to be march, april, june. However when printing out temp I get the following lists:

the first iteration (i=8)

march : 8
april : 8
june : 8
july : 11
august : 9
september : 14
october : 12
november : 13
december : 13

//expected
//march : 8
//april : 8
//june : 8

the second iteration: (i=9)

august : 9
september : 14
october : 12
november : 13
december : 13

//expected:
//may : 9
//august : 9

the third iteration: (i = 11)

july : 11
august : 9
september : 14
october : 12
november : 13
december : 13

//expected:
//july : 11

the fourth iteration (i = 12)

october : 12
november : 13
december : 13

//expected:
//october : 12

the fifth iteration (i = 13)

february : 13
november : 13
decmeber : 13

//as expected

final iteration (i = 14)

january : 14
february : 13
november : 13
december : 13

//expected:
//january : 14
//september : 14

If anybody has any idea what's going on please let me know.

For the sake of completeness:

//WordList Constructor:
public WordList()
{
     this.head = null;
     this.tail = null;
}

//WordList addToTail function:
public void addToTail(Word node)
{
     if (isEmpty())
          head = tail = node;
     else
     {
          tail.next = node;
          tail = node;
      }
}

//WordList removeFromHead funtion
public word removeFromHead()
{
      if (isEmpty())
           return null;
      else
      {
           Word word = head;
           head = head.next;
           return word;
      }
}

/*The sortAlphabetically function not shown but returns expected results*/

Answer 1

I expect that your addToTail(check) call is altering the pointer values within check . You need to capture where the next element in the list will be, before changing any of the pointers in the object you now have.

Also: a simplification to this design would be treating the source of these things as a queue, eg while (check = list.removeFromHead()) (note: assignment, not equal-to) or some such thing like that. Since you're moving things from one list to another, the source list is effectively "being consumed," so the list.head pointer always points to the next element (if any) that you need to grab. This observation would let you modify check with impunity, because you need not rely on its .next pointer.

Answer 2

Ok so the problem was that I was passing the nodes from the original list into the temp list, along with their pointers. So if I was passing check into temp it came along with the remainder of the list that followed check as the pointers were still in tact.

So the method, now correctly functioning is as follows:

private WordList sortWords(WordList words)
{
      int maxScore = words.getMaxScore();
      WordList sortedList = new WordList();

      WordList temp;
      Word check;
      for (int i=0; i<=maxScore; i++)
      {
            temp = new WordList();
            check = words.head;
            while(check != null)
            {
                 if (check.score == i)
                 {
                      Word n = new Word(check.word, check.score);
                      temp.addToTail(n);
                 }
            }

            temp.sortAlphabetically();
            while(!temp.isEmpty())
                 soretedList.addToTail(temp.removeFromHead();
       }
}

The constructor used for word is as follows:

public Word(String _word, int _score)
{
      this.word = _word;
      this.score = _score;
      this.next = null;
}

Thank you to @Mike Robinson, you're answer wasn't quite correct in this specific case but what you said made me realize what my mistake was, while what you're saying in general is correct I needed to deviate from the general as this function is to sort words before they get hashed using Cichelli's method.