Linked lists revisited

Question

hi i have the base code for a linked list implementation:the list, the node, and the iterator position. But the assignment gets harder i have to use this class and have a file read in from the command line and store each word into nodes. I can almost implement this with the String Tokenizer and the buffereader stuff but my other problem comes when i have to represent a arbitrarily long integer value in nodes. Basically i must represent the addition or multiplication of a number such as 50003401 and represent it in nodes storing the coefficient and the exponent so like (5*10^7)+(3*10^3)+(4*10^2)+(1*10^0). I need some help!! How do you store the coefficients and exponents in nodes and have them multiply and deal with all the carries.

Answer 1

Here is my code with spaces in between each class
import java.util.*;
import java.io.*;
public class SortedLinkedList
SortedListNode header; //The list header, references a SortedListNode
// constructor: should initialize to an empty list.
public SortedLinkedList()
     header= new SortedListNode(null);//
// returns an iterator that references the head of the list
public SortedLinkedListItr zeroth( )
     return new SortedLinkedListItr(header);//
// returns true if the list is empty, false otherwise
public boolean isEmpty( )
     return header.next == null;
// returns an iterator that references the first item in the list
public SortedLinkedListItr first( )
     return new SortedLinkedListItr(header.next);//
// inserts the item referenced by x into the list in sorted order.
public void insert(Comparable x)
     SortedLinkedListItr prev=zeroth();//
     SortedLinkedListItr curr=first();//
          while(curr!=null && x.compareTo(curr.retrieve())>0)
               prev.advance();
               curr.advance();
          insert(x);
// returns an iterator that references the item x if it is found in the list
public SortedLinkedListItr find(Comparable x)
     SortedListNode itr= header;//
     while( itr.next != null && !itr.next.element.equals(x))
          itr=itr.next;
          return new SortedLinkedListItr( itr );//
// returns an iterator that references the item that precedes x in the list
// (if such an item exists).
public SortedLinkedListItr findPrevious(Comparable x)
     SortedListNode itr = header;//
     while(itr.next !=null && !itr.next.element.equals(x))
          itr = itr.next;
     return new SortedLinkedListItr(itr);//
// removes the item x from the list, if it exists
public void remove(Comparable x)
     SortedLinkedListItr p =findPrevious(x);//
     if ( p.current.next !=null )
     p.current.next = p.current.next.next;
// prints the items in the list in the order that they appear in the list
public void printList()
     if(isEmpty())
          System.out.print("The list is empty.");
     else
          SortedLinkedListItr itr = first();//
          for(; itr!=null; itr.advance())
               System.out.print(itr.retrieve() + " ");
     System.out.println();
public static void main(String[] args) throws IOException
          SortedLinkedList stringList = new SortedLinkedList();
          if (args.length != 1)
               System.err.println("USAGE: java ReadData input-file\n");
          System.exit(1);
          String filename = args[0];
          FileReader fileReader = new FileReader(filename);
          BufferedReader bufferedReader = new BufferedReader(fileReader);
          System.out.println(filename + " has the following tokens in it:");
          String inputString = bufferedReader.readLine();
          while (inputString!=null)
          StringTokenizer tokenizer = new StringTokenizer(inputString);
          while (tokenizer.hasMoreTokens())
          String token = tokenizer.nextToken();
          stringList.insert(token);
                    inputString = bufferedReader.readLine();
          stringList.printList();
public class SortedLinkedListItr
SortedListNode current; //the node referenced by the iterator.
//constructor: to be used within SortedLinkedList. Sets the iterator
//to reference the node specified in the parameter.
SortedLinkedListItr(SortedListNode theNode)
     current = theNode;
//returns true if the iterator has advanced past the last node in the list.
public boolean isPastEnd( )
          return (current == null);
//returns the item currently referrenced by the iterator (null if the iterator
//is past the end of the list.
public Comparable retrieve( )
          if(
          return (current.element);
// moves the iterator to the next item in the list (does nothing if the
// iterator is past the end of the list.
public void advance( )
          if (current!=null)
          current = current.next;
          else
          current=null;
class SortedListNode
// instance variables
Comparable element; // the element being stored by this node
SortedListNode next; // reference to the next item in the list
//two constructors, one returns a null next, the other allows
//it to be set to reference another node.
SortedListNode(Comparable theElement)
          this(theElement, null);
SortedListNode(Comparable theElement,SortedListNode n)
          element=theElement; next = n;
}