Subversion Repositories programming

// Written by Ira Snyder
// 11-03-2004
import java.io.*;
import java.util.*;

//the class UnorderedTree from pg 338+ in the book
class UnorderedTree {
        private Object root;  //holds the node's data
        private Set subtrees; //holds all of the subtrees
        private int size;     //holds the size of the tree

        public UnorderedTree( ) { } //constructs an empty tree

        public UnorderedTree( Object root ) { //constructs a singleton
                this.root = root;
                subtrees = new HashSet(); //empty set
                size = 1;
        }

        //constructor to create any tree that is not a singleton
        //and is not an empty tree
        public UnorderedTree( Object root, Set trees ) {
                this(root); //calls "UnorderedTree( Object )" constructor

        //loops through all of the subtrees, and adds them this tree's
        //set of subtrees
                for( Iterator it=trees.iterator(); it.hasNext(); ) {
                        Object object = it.next();
                        if( object instanceof UnorderedTree ) {
                                UnorderedTree tree = (UnorderedTree)object;
                                subtrees.add(tree);
                                size += tree.size;
                        }
                }
        }

    //returns the size of the tree
        public int size( ) { return size; }

    //prints the tree in preorder to the specified PrintStream object
        public void printPreOrder( PrintStream ps ) {
        printPreOrderHelper( ps, this ); //print the whole tree in preorder
                ps.println(); //end the line
        }

    //a helper function to the printPreOrder() function
    //it is what actually uses recursion
    //
    //The algorithm behind this is:
    //  1. Print the current node
    //  2. Visit all the subtrees of the current node in PreOrder
    //
        private static void printPreOrderHelper( PrintStream ps, UnorderedTree tree ) {
                ps.print( tree.root + " " ); //print the node
                for( Iterator it=tree.subtrees.iterator(); it.hasNext(); ) {
                        //recurse subtrees in preorder
                        printPreOrderHelper( ps, (UnorderedTree)it.next() );
                }
        }

    //prints the tree in postorder to the specified PrintStream object
        public void printPostOrder( PrintStream ps ) {
                printPostOrderHelper( ps, this ); //print the whole tree in postorder
                ps.println(); //end the line
        }

    //a helper function for the printPostOrder() function
    //it is what actually uses recursion to print the tree
    //
    //The algorithm behind this is:
    //  1. Visit all the subtrees of the current node in PostOrder
    //  2. Print the current node
    //
        public static void printPostOrderHelper( PrintStream ps, UnorderedTree tree ) {
                for( Iterator it=tree.subtrees.iterator(); it.hasNext(); ) {
                        //recurse subtrees in postorder
                        printPostOrderHelper( ps, (UnorderedTree)it.next() );
                }
                ps.print( tree.root + " "); //print the node
        }

    //prints the tree in LevelOrder to the specified PrintStream object
    //
    //This is the algorithm (from pg 342-343 in the book):
    //  1. Initialize a Queue
    //  2. Add the root to the queue
    //  3. Repeat steps 4-6 until the queue is empty
    //  4. Remove the first node x from the queue
    //  5. Visit x
    //  6. Add all the children of x to the queue
    //
        public void printLevelOrder( PrintStream ps ) {
                Queue q = new Queue();

                q.enqueue(this); //add the root
                
                while( !q.isEmpty() ) {
                        //remove the first item in the queue
                        UnorderedTree temp = (UnorderedTree)q.dequeue();

                        ps.print(temp.root + " "); //visit the node

                        //add all the children of temp to the queue
                        for( Iterator it=temp.subtrees.iterator(); it.hasNext(); ) {
                                q.enqueue( it.next() );
                        }
                }
                ps.println(); //end the current line
        }

} //end class UnorderedTree