Questions on HW3-Summer08

• In general, a node in linked list (we teach singly-linked in this class) contains some data and a reference to the next node in the list. The tail (last node) of the list is a node whose next points to null. In the case of the StringNode, the data is a String and the next node is of type StringNode. Dawn Finney

• You are trying to create a LinkedList data structure. StringList will have a reference to the head (first node) of the list. You can access the rest of the list by moving from node to node because each node has a reference to the next node in the list. You can think of the node as signs to another room for recitation since it got moved. You (the list) only know where the first sign is at the original recitation room. Each sign will contain some information (data) let's say the distance to the next sign and directions to the next sign in the series (next node). Thus to find the new recitation room, you have to move from sign to sign (node to node) to finally find the last one that marks the new room. You know this sign is the last one because this sign will have no directions to the next sign (null). Dawn Finney

public StringList(){…}
public StringList(StringNode head){…}

• Methods with no return types and have the same name as the class that houses them are always the constructors. Dawn Finney.

• The general idea is that your StringList can contain any number of nodes from 0 to infinity (memory permitting). You have to make sure your methods will handle all possible sizes of the list. You should only turn in two files (StringNode and StringList) for the assignment. You can declare new StringNodes similar to the way you have declared other classes in the past such as Picture or String. The first node in the list and the head of the list are the SAME thing. Dawn Finney
• To elaborate on what Dawn said: Remember that you can make multiple instances of a class. A StringList with 10 nodes will actually have 10 Node instances comprising the list. However, remember that you can only directly access the first node from StringList...you must walk through the list using the next references to access all the other nodes. Student1086

• I'll see what I can do about this one, but in the mean time you should do your own testing and try to handle all the cases. I'd do it in a main method to make things easier. Dawn Finney.
• I would really prefer that you write your own test methods (I don't like giving out test code because this leads students to believe that their code only has to work for this code...which is bad because then the code might not work in other important cases). Essentially, write lines in your main method or another test class, call your methods, do a println of your StringList toString, and make sure it prints what is expected. This could be just a couple lines, but I highly suggest that you spend some time and make sure all your methods work, especially in special cases (such as when the list is empty, the list only has one node, the node is the last node in the list, the node is the first node in the list, etc). How long and complete you test is ultimately up to you, but there seems to be a strong correspondence between grades on homework and amount/quality of testing. Student1086

• You need this free program WinRAR. It's just a different archiving format from something like .zip. Dawn Finney.

• Alphabetically as noted in the javadoc. Dawn Finney

• No a main method is not required, but it is recommended as you need to test and see if your methods work for all the cases. Dawn Finney

if (current.getNext() != null)

• This error occurs when you have code listed after your method returns (this return will always occur at this point). An example of an unreachable statement is:

  public String capitalize(String s){
    if(Character.isLowerCase(s.charAt(0)){
       if (s.length > 1)
         s = Character.toUpperCase(s.charAt(0)) + s.substring(1, s.length());
       else
         s = Character.toUpperCase(s.charAt(0));
    }
    return s;
    System.out.println("New String: " + s);
  }

  The last line (System.out.println("New String: " + s);) is an unreachable statement, because the method already "returns" before that line and will always return before that line. This example however does not have the same problem:

  public String capitalize(String s){
    if(Character.isLowerCase(s.charAt(0)){
       if (s.length > 1)
         return Character.toUpperCase(s.charAt(0)) + s.substring(1, s.length());
       else
         return Character.toUpperCase(s.charAt(0));
    }
    return s;
  }

  There are return statements before the last return s;, but note that the previous return statements are constrained by conditionals (if and else). The returns in this example all signal the end of the method, whereas in the previous example, the return is misplaced and occurs before the entire method completes. Dawn Finney

• You have an infinite loop. You can hit the "reset" button to stop it. I would go back and change your loops and make sure you are incrementing for this homework it's probably something like current = current.getNext();. Dawn Finney

StringNode one = new StringNode("one");
  StringNode two = new StringNode("two");
  StringNode three = new StringNode("three");
  StringNode four = new StringNode("four");

• Well I would print the list before the method and after the method. It is very important to figure out if your toString method is working first and then proceed with other methods. In this homework, I would do one method at a time. Test it to make sure it's working before moving on. You might not actually be creating the list in the first place. Are you linking those nodes together, because with the lines of code you have posted here, you have no list, just free floating nodes who don't know about each other. Dawn Finney

• A toString() method for any class return a String representation of that class, but most quickly realize that a "representation of a class" is really broad. It is okay if the method only return the data. I would take it a step further and also return the data of its next as well (only the data not the entire node!). Dawn Finney.

public static void main(String[]args){
  //declare the nodes
  StringNode dawnNode = new StringNode("Dawn");
  StringNode katieNode = new StringNode("Katie");
  StringNode smithNode = new StringNode("Professor REMOVED");
  StringNode ricardoNode = new StringNode("Ricardo");
  //link the nodes
  smithNode.setNext(katieNode);
  katieNode.setNext(ricardoNode);
  //create a list
  StringList cs1316List = new StringList(smithNode);
  //print the list before
  System.out.println(cs1316List);
  //test the method
  cs1316List.addToFront(dawnNode);
  //print the list after
  System.out.println(cs1316List);
}

• Read the questions and answers already posted here. Dawn Finney.

  StringNode one = new StringNode("one");
  StringNode two = new StringNode("two");
  StringNode three = new StringNode("three");
  StringNode four = new StringNode("four");

• I already answered this in my own example. Dawn Finney.

1 error found:
File: C:\Users\Works\2008\Georgia Tech\2008 Summer\Rep Behavior CS 1316\HW03\StringNode.java  [line: 56]
Error: C:\Users\Works\2008\Georgia Tech\2008 Summer\Rep Behavior CS 1316\HW03\StringNode.java:56: non-static method toString() cannot be referenced from a static context

• It means that you are calling the toString() method incorrectly. You are probably calling it like this StringNode.toString(), which is wrong. You need a new instance of StringNode and then call the toString() on that. For instance:

    StringNode dNode = new StringNode("D");
    System.out.println(dNode.toString()); // same as System.out.println(dNode);

  Dawn Finney

• I would suggest checking your toString method. Make sure you are printing the data at each node (hence, if you have a pointer than jumps through the list, make sure you are printing the data pointed to by the pointer). I tend to think this is your problem, but it could also be a problem with one of your constructors (you did set head to null for the empty constructor and to the passed in StringNode for the other constructor, right?) or your addToFront (are you dealing with special cases properly?). Student1086

• It will work, because when you call System.out.println on a StringList, it is equivalent to calling System.out.println(cs1316list.toString()); , which would print a String since toString returns a String. Student1086

Links to this Page

• Homeworks-Summer 2008 last edited on 22 July 2008 at 4:06 pm by dhcp-207-151-195-107.vonkarman.net
• Soap Box Archive-Summer 2008 last edited on 6 August 2008 at 1:49 pm by dhcp-207-151-195-107.vonkarman.net