Please offer help on indexing a textbook

Question

I really need help on an assignment. It is supposed to create an index for a textbook and it has to be implemnted using trees.
Generate an index for a book.
The Input:
The input file is specified as a command-line argument (use args). Be certain to check the validity of the file.
The input file consists of a set of index entries. Each line consists of the string IX:, followed by an index entry name enclosed in braces, followed by a page number that is enclosed in braces. Each ! in an index entry name represets a sub-level. A |( represents the start of a range and a |) represents the end of the range. Occasionally, this will be the same page, and in that case, only output a single page number. Otherwise, do not collapse or expand ranges on your own. As an example, here's a sample input:
IX: Series {2}
IX: {Series!geometric|(} {4}
IX: {Euler's constant} {4}
IX: {Series!geometric|)} {4}
IX: {Series!arithmetic|(} {4}
IX: {Series!arithmetic|)} {5}
IX: {Series!harmonic|(} {5}
IX: {Euler's constant} {5}
IX: {Series!harmonic|)} {5}
IX: Series {5}
The corresponding output is:
Euler's constant: 4, 5
Series: 2-5
arithmetic: 4-5
geometric: 4
harmonic: 5
(1)You must construct a general tree with a root node(the value stored in the root node will just be the word INDEX which should be the first item printed out - this is in addition to the output specification in the text) and its children consisting of top-level index terms, the next level of children consisting of sub -level index terms and so on;
(2)Each node(except the root) must store the index term and page ranges;
(3)In the general tree implementation the siblings need to be stored in a certain way so that a certain tree traversal algorithm will print out the index in the correct way.
   import java.io.*;          
// BinaryTree class; stores a binary tree.
// CONSTRUCTION: with (a) no parameters or (b) an object to
//    be placed in the root of a one-element tree.
// *******************PUBLIC OPERATIONS**********************
// Various tree traversals, size, height, isEmpty, makeEmpty.
// Also, the following tricky method:
// void merge( Object root, BinaryTree t1, BinaryTree t2 )
//                        --> Construct a new tree
// *******************ERRORS*********************************
// Error message printed for illegal merges.
* BinaryTree class that illustrates the calling of
* BinaryNode recursive routines and merge.
    public class BinaryTree //extends BinaryNode
      BinaryNode name = new BinaryNode();
       public static void main(String []args)
         String denem = "flag";
         BinaryTree index = new BinaryTree(denem);
         BinaryTree.insert(denem);
         System.out.println(index.infix(denem));
         System.exit(0);
       public BinaryTree( )
         name = null;
       public BinaryTree( String rootItem )
         BinaryNode name = new BinaryNode( rootItem, null, null );
       public void printInOrder( )
         //if( root != null )
         name.printInOrder( );
       public BinaryNode insert(String str, BinaryNode t)
         if(t == null)
            t = new BinaryNode(str, null, null);
         else if(str.compareTo(t.root) < 0)
            t.left = insert(str, t.left);
         else if(str.compareTo(t.root) > 0)
            t.right = insert(str, t.right);     
         return t;
       public BinaryNode insert(String str)
         BinaryNode n = root;
         return insert(str, n);
      // allows the pages to be printed out
       public String toString()
         String concat = name.getRoot();  
         return concat;
       public static void infix(BinaryNode t)     
         if (t != null)
            System.out.print("(");
            infix(t.getLeft());
            System.out.print(t);
            infix(t.getRight());
            System.out.print(")");
   // Class binary node
    final class BinaryNode
      protected String root;    //the name
      protected BinaryNode left;
      protected BinaryNode right;
      //protected String pages;
       public BinaryNode( )
         this( null, null, null); //, null);
       public BinaryNode( String root, BinaryNode left, BinaryNode right) //, String pages )
         root    = this.root;
         left    = this.left;
         right   = this.right;
       //  pages   = this.pages;
      * Return the size of the binary tree rooted at t.
       public static int size( BinaryNode t )
         if( t == null )
            return 0;
         else
            return 1 + size( t.left ) + size( t.right );
      * Return the height of the binary tree rooted at t.
       public static int height( BinaryNode t )
         if( t == null )
            return -1;
         else
            return 1 + Math.max( height( t.left ), height( t.right ) );
      // Print tree rooted at current node using inorder traversal.
       public void printInOrder( )
         if( left != null )
            left.printInOrder( );            // Left
         System.out.println( root );       // Node
         if( right != null )
            right.printInOrder( );          // Right         
       public String getRoot( )
         return root;
       public BinaryNode getLeft( )
         return left;
       public BinaryNode getRight( )
         return right;
       /*public void setElement( Object x )
         element = x;
       public void setLeft( BinaryNode t )
         left = t;
       public void setRight( BinaryNode t )
         right = t;
   } // end of class node
This is the solution done using linked lists and treemap.
   import java.io.*;                         // to read the file
  A red-black tree is a binary search tree where every node has two children or is a leaf.
  It ensures O(log N) search times, at a cost of a more complicated insertion (and deletion)
  process. In a red-black tree, every node is colored either red or black, with a black root
  node, though a black root node isn't a requirement. In addition, if a node is red, its
  children must be black and every path from root to leaf (or null child node) must
  contain the same number of black nodes. These rules allow balancing
   import java.util.TreeMap;
   import java.util.Comparator;
   import java.util.StringTokenizer;
   public interface Iterator An iterator over a collection. Iterator takes the place of
   Enumeration in the Java collections framework. Iterators differ from enumerations in two ways:
   Iterators allow the caller to remove elements from the underlying collection during the iteration
   with well-defined semantics.
   import java.util.Iterator;
   import java.util.LinkedList;
   import java.util.ArrayList;
    public class IndexGenerator3
      private static final String START    = "|(";
      private static final String END      = "|)";
      private static final String SUBTOPIC = "!";
      private static final char SUBTOP= SUBTOPIC.charAt(0);
        private static final String INPUT = "hw3.in";     
      //private static final String INPUT = "input.txt";
       private static class Section
         public String name;
         public int start = -1;
         public int end = -1;
         //public int page;
    private LinkedList pages = new LinkedList();
         //constructor
          public Section(String name, int start, int end, int page)
            this.name = name;
            this.start = start;
            this.end = end;
            if(page >= 0) //this is for error checking
               addPage(page);
          public void addPage(int page)
            pages.add(new Integer(page));
          public boolean isValid()
            return (start >= 0 && end >= 0 && pages.size() == 0) || pages.size() > 0;
      // allows the pages to be printed out
          public String toString()
            String concat = "";
            String szName = name;
            while(name.indexOf(SUBTOPIC) >= 0)      // returns tbe index of the first occurrence of the character. it takes a string or character as input parameter
               concat += " ";
               name = name.substring(name.indexOf(SUBTOPIC) +1);
            } //end of while
            concat += name + ": ";
            if (start >= 0)
               concat += String.valueOf(start);
               if (end >= 0 && end != start)
                  concat += "-" +end;
            else if (end >= 0)
               concat += String.valueOf(end);
            else
               Iterator iterator = pages.iterator();
               while (iterator.hasNext())
                  concat += iterator.next() + ", ";
               if (end < concat.length())
                  concat= concat.substring(0, concat.length()-2);
            return concat;
       public static void main(String[] args)
         try
            FileReader fr = new FileReader(INPUT);
            BufferedReader inFile = new BufferedReader(fr);
            TreeMap map = new TreeMap(
                   new Comparator()
                      public int compare(Object o1, Object o2)
                        String s1= (String) o1;
                        String s2= (String) o2;
                        s1.replace(SUBTOP, ' ');
                        s2.replace(SUBTOP, ' ');
                        s1.toLowerCase();
                        s2.toLowerCase();
                        return s1.compareTo(s2);
                        //return s1.compareToIgnoreCase(s2);     //Compares two strings lexicographically, ignoring case considerations.
                      public boolean equals(Object obj)
                        return false;
            String line = null;
            for (int i = 0; (line = inFile.readLine()) != null; i++)
               StringTokenizer st = new StringTokenizer(line, "{}");
               //if (st.countTokens() != 4)
                  //System.err.println("Error, Please correct: '" +line +"'");
                  //continue;
               st.nextToken();
               String name= st.nextToken();
               st.nextToken();
               String szPage= st.nextToken();
               int start= -1;
               int end= -1;
               int page= -1;
               if (name.endsWith(START))
                  name= name.substring(0, name.length() -START.length());
                  start= Integer.parseInt(szPage);
               else if (name.endsWith(END))  //string built in function endsWith()
                  name= name.substring(0, name.length() - END.length());
                  end= Integer.parseInt(szPage);
               else
                  page = Integer.parseInt(szPage); //convet the string into integers
               Section section = (Section) map.get(name); //???????????
               if (section == null)    //if object section is null, create new section object and initialize
                  section = new Section(name, start, end, page); //start cannot be omitted
                  map.put(name, section);
               else if (start >= 0)   //if more pages under
                  section.start= start;
               else if (end >= 0)   //if more pages under same heading are found
                  section.end = end;  // overwrite ???
               else if (page >= 0)     //if there are more pages under the same heading add a page. euler s constant
                  section.addPage(page);
            fr.close();                //close the input stream
            System.out.println("\nIndex:");
            ArrayList invalid= new ArrayList(); // prevents marginal occurences of repetitive header lines
            Iterator sections= map.values().iterator();
            while (sections.hasNext())
               Section section= (Section) sections.next();
               if (section.isValid())
                  System.out.println(" " + section);
               else
                  invalid.add(section);
             catch(FileNotFoundException exception)
            { System.err.println("File not found"); }
             catch (IOException exception)
            { System.out.println(exception); }
      }// end of main
   //     public void
   }  // end of class index generator
   I'm even offering the buy the program to make it more proffessional...the payment is as much duke dollars as i can give...We can also negotiate on e bay using real dollars, but the assignemtn is due tonite and i don t have much time... If someone will most kindly take a look, i will be greatly indebted and humbled...isn t there anyone on this site who actually loves solving this kinda stuff?

Answer 1

actually, your solution was how I found about this forum. go to google,
type in "index a textbook" + java, the forum pops up. Your solution has helped me a lot, I based my assignment on yours, just look at my main file. The difference was, I had to use a tree. That was more confusing than a linked list.