Subversion Repositories programming

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

class Driver {

        public static void main( String[] args ) throws Exception {
                
                //create both example trees
                UnorderedTree tree1 = createTreeOne();
                UnorderedTree tree2 = createTreeTwo();

                tree1.printPreOrder( System.out );
                tree1.printPostOrder( System.out );
                tree1.printLevelOrder( System.out );
                System.out.println(); //blank line

                tree2.printPreOrder( System.out );
                tree2.printPostOrder( System.out );
                tree2.printLevelOrder( System.out );
        }

        //method to create and return tree 1
        public static UnorderedTree createTreeOne( ) {
                
                //create all leaf nodes
                UnorderedTree treeD = new UnorderedTree("D");
                UnorderedTree treeE = new UnorderedTree("E");
                UnorderedTree treeF = new UnorderedTree("F");
                UnorderedTree treeK = new UnorderedTree("K");
                UnorderedTree treeL = new UnorderedTree("L");
                UnorderedTree treeM = new UnorderedTree("M");
                UnorderedTree treeI = new UnorderedTree("I");
                
                //create Set of subtrees of treeC
                Set subtreesOfC = new HashSet();
                subtreesOfC.add(treeD);
                subtreesOfC.add(treeE);
                
                //create treeC
                UnorderedTree treeC = new UnorderedTree("C", subtreesOfC);
                
                //create Set of subtrees of treeG
                Set subtreesOfG = new HashSet();
                subtreesOfG.add(treeF);

                //create treeG
                UnorderedTree treeG = new UnorderedTree("G", subtreesOfG);
                
                //create Set of subtrees of treeB
                Set subtreesOfB = new HashSet();
                subtreesOfB.add(treeC);
                subtreesOfB.add(treeG);

                //create treeB
                UnorderedTree treeB = new UnorderedTree("B", subtreesOfB);

                //--------------------------------//
                // now starting on the right tree //
                //--------------------------------//
                
                //create Set of subtrees of treeJ
                Set subtreesOfJ = new HashSet();
                subtreesOfJ.add(treeK);
                subtreesOfJ.add(treeL);
                subtreesOfJ.add(treeM);

                //create treeJ
                UnorderedTree treeJ = new UnorderedTree("J", subtreesOfJ);
                
                //create Set of subtrees of treeH
                Set subtreesOfH = new HashSet();
                subtreesOfH.add(treeJ);
                subtreesOfH.add(treeI);

                //create treeH
                UnorderedTree treeH = new UnorderedTree("H", subtreesOfH);

                //create Set of subtrees of treeA
                Set subtreesOfA = new HashSet();
                subtreesOfA.add(treeB);
                subtreesOfA.add(treeH);

                //create treeA
                UnorderedTree treeA = new UnorderedTree("A", subtreesOfA);
                
                //return the completed tree
                return treeA;
        }
        
        //method to create and return tree 2
        public static UnorderedTree createTreeTwo( ) {
                
                //create all leaf nodes
                UnorderedTree treeO = new UnorderedTree("O");
                UnorderedTree treeP = new UnorderedTree("P");
                UnorderedTree treeQ = new UnorderedTree("Q");
                UnorderedTree treeS = new UnorderedTree("S");
                UnorderedTree treeT = new UnorderedTree("T");
                UnorderedTree treeX = new UnorderedTree("X");
                UnorderedTree treeU = new UnorderedTree("U");
                UnorderedTree treeV = new UnorderedTree("V");
                UnorderedTree treeW = new UnorderedTree("W");
                UnorderedTree treeZ = new UnorderedTree("Z");
                UnorderedTree tree1 = new UnorderedTree("1");
                UnorderedTree tree2 = new UnorderedTree("2");
                UnorderedTree tree3 = new UnorderedTree("3");
                UnorderedTree treeF = new UnorderedTree("F");
                UnorderedTree treeK = new UnorderedTree("K");
                UnorderedTree treeM = new UnorderedTree("M");
                UnorderedTree treeI = new UnorderedTree("I");

                //now create subtrees of R
                Set subtreesOfR = new HashSet();
                subtreesOfR.add(treeS);
                subtreesOfR.add(treeT);
                subtreesOfR.add(treeX);

                //create treeR
                UnorderedTree treeR = new UnorderedTree("R",subtreesOfR);

                //create subtrees of N
                Set subtreesOfN = new HashSet();
                subtreesOfN.add(treeO);
                subtreesOfN.add(treeP);
                subtreesOfN.add(treeQ);

                //create treeN
                UnorderedTree treeN = new UnorderedTree("N",subtreesOfN);

                //create subtrees of D
                Set subtreesofD = new HashSet();
                subtreesofD.add(treeR);
                subtreesofD.add(treeU);
                subtreesofD.add(treeV);
                subtreesofD.add(treeW);

                //create treeD
                UnorderedTree treeD = new UnorderedTree("D",subtreesofD);

                //create subtrees of Y
                Set subtreesOfY = new HashSet();
                subtreesOfY.add(treeZ);
                subtreesOfY.add(tree1);
                subtreesOfY.add(tree2);

                //create treeY
                UnorderedTree treeY = new UnorderedTree("Y",subtreesOfY);

                //create subtrees of 4
                Set subtreesOf4 = new HashSet();
                subtreesOf4.add(treeN);

                //create tree4
                UnorderedTree tree4 = new UnorderedTree("4",subtreesOf4);

                //create subtrees of E
                Set subtreesOfE = new HashSet();
                subtreesOfE.add(tree3);
                subtreesOfE.add(treeD);

                //create treeE
                UnorderedTree treeE = new UnorderedTree("E",subtreesOfE);

                //create subtrees of L
                Set subtreesOfL = new HashSet();
                subtreesOfL.add(treeY);

                //create treeL
                UnorderedTree treeL = new UnorderedTree("L",subtreesOfL);

                //create subtrees of C
                Set subtreesOfC = new HashSet();
                subtreesOfC.add(tree4);
                subtreesOfC.add(treeE);

                //create treeC
                UnorderedTree treeC = new UnorderedTree("C",subtreesOfC);

                //create subtrees of G
                Set subtreesOfG = new HashSet();
                subtreesOfG.add(treeF);

                //create treeG
                UnorderedTree treeG = new UnorderedTree("G",subtreesOfG);

                //create subtrees of J
                Set subtreesOfJ = new HashSet();
                subtreesOfJ.add(treeK);
                subtreesOfJ.add(treeL);
                subtreesOfJ.add(treeM);

                //create treeJ
                UnorderedTree treeJ = new UnorderedTree("J",subtreesOfJ);

                //create subtrees of B
                Set subtreesOfB = new HashSet();
                subtreesOfB.add(treeC);
                subtreesOfB.add(treeG);

                //create treeB
                UnorderedTree treeB = new UnorderedTree("B",subtreesOfB);

                //create subtrees of H
                Set subtreesOfH = new HashSet();
                subtreesOfH.add(treeI);
                subtreesOfH.add(treeJ);

                //create treeH
                UnorderedTree treeH = new UnorderedTree("H",subtreesOfH);

                //create subtrees of A
                Set subtreesOfA = new HashSet();
                subtreesOfA.add(treeB);
                subtreesOfA.add(treeH);

                //create treeA
                UnorderedTree treeA = new UnorderedTree("A",subtreesOfA);
                
                //return the completed tree
                return treeA;
        }
        
} //end of class Driver


/*
      BufferedReader kb = new BufferedReader(
                              new InputStreamReader(System.in));


      BufferedReader br = new BufferedReader(
                              new InputStreamReader(
                                  new FileInputStream(filename)));

      PrintStream ps = new PrintStream(
                           new FileOutputStream(
                               new File(filename)));

*/