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