Subversion Repositories programming

Rev

Rev 26 | Show entire file | Ignore whitespace | Details | Blame | Last modification | View Log | RSS feed

Rev 26 Rev 27
Line 5... Line 5...
5 
import java.io.*;
 5 
import java.io.*;
6 
import java.util.*;
 6 
import java.util.*;
7 
 
 7 
 
8 
class Driver {
 8 
class Driver {
9 
 
 9 
 
10 
	public static void main( String[] args ) throws Exception {
 10 
    public static void main( String[] args ) throws Exception {
11
11 
 
12 
		//create both example trees
 12 
        //create both example trees
13 
		UnorderedTree tree1 = createTreeOne();
 13 
        UnorderedTree tree1 = createTreeOne();
14 
		UnorderedTree tree2 = createTreeTwo();
 14 
        UnorderedTree tree2 = createTreeTwo();
15
15
16 
        //tree 1
 16 
        //tree 1
17 
        System.out.println("TreeOne's size is: " + tree1.size());
 17 
        System.out.println("TreeOne's size is: " + tree1.size());
18 
        System.out.println("Starting TreeOne's Traversals...");
 18 
        System.out.println("Starting TreeOne's Traversals...");
19 
        System.out.print("PreOrder: ");
 19 
        System.out.print("PreOrder: ");
Line 33... Line 33...
33 
        tree2.printPostOrder( System.out );
 33 
        tree2.printPostOrder( System.out );
34 
        System.out.print("LevelOrder: ");
 34 
        System.out.print("LevelOrder: ");
35 
        tree2.printLevelOrder( System.out );
 35 
        tree2.printLevelOrder( System.out );
36 
    }
 36 
    }
37 
 
 37 
 
38 
	//method to create and return tree 1
 38 
    //method to create and return tree 1
39 
	public static UnorderedTree createTreeOne( ) {
 39 
    public static UnorderedTree createTreeOne( ) {
40
40 
 
41 
		//create all leaf nodes
 41 
        //create all leaf nodes
42 
		UnorderedTree treeD = new UnorderedTree("D");
 42 
        UnorderedTree treeD = new UnorderedTree("D");
43 
		UnorderedTree treeE = new UnorderedTree("E");
 43 
        UnorderedTree treeE = new UnorderedTree("E");
44 
		UnorderedTree treeF = new UnorderedTree("F");
 44 
        UnorderedTree treeF = new UnorderedTree("F");
45 
		UnorderedTree treeK = new UnorderedTree("K");
 45 
        UnorderedTree treeK = new UnorderedTree("K");
46 
		UnorderedTree treeL = new UnorderedTree("L");
 46 
        UnorderedTree treeL = new UnorderedTree("L");
47 
		UnorderedTree treeM = new UnorderedTree("M");
 47 
        UnorderedTree treeM = new UnorderedTree("M");
48 
		UnorderedTree treeI = new UnorderedTree("I");
 48 
        UnorderedTree treeI = new UnorderedTree("I");
49
49 
 
50 
		//create Set of subtrees of treeC
 50 
        //create Set of subtrees of treeC
51 
		Set subtreesOfC = new HashSet();
 51 
        Set subtreesOfC = new HashSet();
52 
		subtreesOfC.add(treeD);
 52 
        subtreesOfC.add(treeD);
53 
		subtreesOfC.add(treeE);
 53 
        subtreesOfC.add(treeE);
54
54 
 
55 
		//create treeC
 55 
        //create treeC
56 
		UnorderedTree treeC = new UnorderedTree("C", subtreesOfC);
 56 
        UnorderedTree treeC = new UnorderedTree("C", subtreesOfC);
57
57 
 
58 
		//create Set of subtrees of treeG
 58 
        //create Set of subtrees of treeG
59 
		Set subtreesOfG = new HashSet();
 59 
        Set subtreesOfG = new HashSet();
60 
		subtreesOfG.add(treeF);
 60 
        subtreesOfG.add(treeF);
61 
 
 61 
 
62 
		//create treeG
 62 
        //create treeG
63 
		UnorderedTree treeG = new UnorderedTree("G", subtreesOfG);
 63 
        UnorderedTree treeG = new UnorderedTree("G", subtreesOfG);
64
64
65 
		//create Set of subtrees of treeB
 65 
        //create Set of subtrees of treeB
66 
		Set subtreesOfB = new HashSet();
 66 
        Set subtreesOfB = new HashSet();
67 
		subtreesOfB.add(treeC);
 67 
        subtreesOfB.add(treeC);
68 
		subtreesOfB.add(treeG);
 68 
        subtreesOfB.add(treeG);
69 
 
 69 
 
70 
		//create treeB
 70 
        //create treeB
71 
		UnorderedTree treeB = new UnorderedTree("B", subtreesOfB);
 71 
        UnorderedTree treeB = new UnorderedTree("B", subtreesOfB);
72 
 
 72 
 
73 
		//create Set of subtrees of treeJ
 73 
        //create Set of subtrees of treeJ
74 
		Set subtreesOfJ = new HashSet();
 74 
        Set subtreesOfJ = new HashSet();
75 
		subtreesOfJ.add(treeK);
 75 
        subtreesOfJ.add(treeK);
76 
		subtreesOfJ.add(treeL);
 76 
        subtreesOfJ.add(treeL);
77 
		subtreesOfJ.add(treeM);
 77 
        subtreesOfJ.add(treeM);
78 
 
 78 
 
79 
		//create treeJ
 79 
        //create treeJ
80 
		UnorderedTree treeJ = new UnorderedTree("J", subtreesOfJ);
 80 
        UnorderedTree treeJ = new UnorderedTree("J", subtreesOfJ);
81
81 
 
82 
		//create Set of subtrees of treeH
 82 
        //create Set of subtrees of treeH
83 
		Set subtreesOfH = new HashSet();
 83 
        Set subtreesOfH = new HashSet();
84 
		subtreesOfH.add(treeJ);
 84 
        subtreesOfH.add(treeJ);
85 
		subtreesOfH.add(treeI);
 85 
        subtreesOfH.add(treeI);
86 
 
 86 
 
87 
		//create treeH
 87 
        //create treeH
88 
		UnorderedTree treeH = new UnorderedTree("H", subtreesOfH);
 88 
        UnorderedTree treeH = new UnorderedTree("H", subtreesOfH);
89 
 
 89 
 
90 
		//create Set of subtrees of treeA
 90 
        //create Set of subtrees of treeA
91 
		Set subtreesOfA = new HashSet();
 91 
        Set subtreesOfA = new HashSet();
92 
		subtreesOfA.add(treeB);
 92 
        subtreesOfA.add(treeB);
93 
		subtreesOfA.add(treeH);
 93 
        subtreesOfA.add(treeH);
94 
 
 94 
 
95 
		//create treeA
 95 
        //create treeA
96 
		UnorderedTree treeA = new UnorderedTree("A", subtreesOfA);
 96 
        UnorderedTree treeA = new UnorderedTree("A", subtreesOfA);
97
97 
 
98 
		//return the completed tree
 98 
        //return the completed tree
99 
		return treeA;
 99 
        return treeA;
100 
	}
 100 
    }
101
101 
 
102 
	//method to create and return tree 2
 102 
    //method to create and return tree 2
103 
	public static UnorderedTree createTreeTwo( ) {
 103 
    public static UnorderedTree createTreeTwo( ) {
104
104 
 
105 
		//create all leaf nodes
 105 
        //create all leaf nodes
106 
		UnorderedTree treeO = new UnorderedTree("O");
 106 
        UnorderedTree treeO = new UnorderedTree("O");
107 
		UnorderedTree treeP = new UnorderedTree("P");
 107 
        UnorderedTree treeP = new UnorderedTree("P");
108 
		UnorderedTree treeQ = new UnorderedTree("Q");
 108 
        UnorderedTree treeQ = new UnorderedTree("Q");
109 
		UnorderedTree treeS = new UnorderedTree("S");
 109 
        UnorderedTree treeS = new UnorderedTree("S");
110 
		UnorderedTree treeT = new UnorderedTree("T");
 110 
        UnorderedTree treeT = new UnorderedTree("T");
111 
		UnorderedTree treeX = new UnorderedTree("X");
 111 
        UnorderedTree treeX = new UnorderedTree("X");
112 
		UnorderedTree treeU = new UnorderedTree("U");
 112 
        UnorderedTree treeU = new UnorderedTree("U");
113 
		UnorderedTree treeV = new UnorderedTree("V");
 113 
        UnorderedTree treeV = new UnorderedTree("V");
114 
		UnorderedTree treeW = new UnorderedTree("W");
 114 
        UnorderedTree treeW = new UnorderedTree("W");
115 
		UnorderedTree treeZ = new UnorderedTree("Z");
 115 
        UnorderedTree treeZ = new UnorderedTree("Z");
116 
		UnorderedTree tree1 = new UnorderedTree("1");
 116 
        UnorderedTree tree1 = new UnorderedTree("1");
117 
		UnorderedTree tree2 = new UnorderedTree("2");
 117 
        UnorderedTree tree2 = new UnorderedTree("2");
118 
		UnorderedTree tree3 = new UnorderedTree("3");
 118 
        UnorderedTree tree3 = new UnorderedTree("3");
119 
		UnorderedTree treeF = new UnorderedTree("F");
 119 
        UnorderedTree treeF = new UnorderedTree("F");
120 
		UnorderedTree treeK = new UnorderedTree("K");
 120 
        UnorderedTree treeK = new UnorderedTree("K");
121 
		UnorderedTree treeM = new UnorderedTree("M");
 121 
        UnorderedTree treeM = new UnorderedTree("M");
122 
		UnorderedTree treeI = new UnorderedTree("I");
 122 
        UnorderedTree treeI = new UnorderedTree("I");
123 
 
 123 
 
124 
		//now create subtrees of R
 124 
        //now create subtrees of R
125 
		Set subtreesOfR = new HashSet();
 125 
        Set subtreesOfR = new HashSet();
126 
		subtreesOfR.add(treeS);
 126 
        subtreesOfR.add(treeS);
127 
		subtreesOfR.add(treeT);
 127 
        subtreesOfR.add(treeT);
128 
		subtreesOfR.add(treeX);
 128 
        subtreesOfR.add(treeX);
129 
 
 129 
 
130 
		//create treeR
 130 
        //create treeR
131 
		UnorderedTree treeR = new UnorderedTree("R",subtreesOfR);
 131 
        UnorderedTree treeR = new UnorderedTree("R",subtreesOfR);
132 
 
 132 
 
133 
		//create subtrees of N
 133 
        //create subtrees of N
134 
		Set subtreesOfN = new HashSet();
 134 
        Set subtreesOfN = new HashSet();
135 
		subtreesOfN.add(treeO);
 135 
        subtreesOfN.add(treeO);
136 
		subtreesOfN.add(treeP);
 136 
        subtreesOfN.add(treeP);
137 
		subtreesOfN.add(treeQ);
 137 
        subtreesOfN.add(treeQ);
138 
 
 138 
 
139 
		//create treeN
 139 
        //create treeN
140 
		UnorderedTree treeN = new UnorderedTree("N",subtreesOfN);
 140 
        UnorderedTree treeN = new UnorderedTree("N",subtreesOfN);
141 
 
 141 
 
142 
		//create subtrees of D
 142 
        //create subtrees of D
143 
		Set subtreesofD = new HashSet();
 143 
        Set subtreesofD = new HashSet();
144 
		subtreesofD.add(treeR);
 144 
        subtreesofD.add(treeR);
145 
		subtreesofD.add(treeU);
 145 
        subtreesofD.add(treeU);
146 
		subtreesofD.add(treeV);
 146 
        subtreesofD.add(treeV);
147 
		subtreesofD.add(treeW);
 147 
        subtreesofD.add(treeW);
148 
 
 148 
 
149 
		//create treeD
 149 
        //create treeD
150 
		UnorderedTree treeD = new UnorderedTree("D",subtreesofD);
 150 
        UnorderedTree treeD = new UnorderedTree("D",subtreesofD);
151 
 
 151 
 
152 
		//create subtrees of Y
 152 
        //create subtrees of Y
153 
		Set subtreesOfY = new HashSet();
 153 
        Set subtreesOfY = new HashSet();
154 
		subtreesOfY.add(treeZ);
 154 
        subtreesOfY.add(treeZ);
155 
		subtreesOfY.add(tree1);
 155 
        subtreesOfY.add(tree1);
156 
		subtreesOfY.add(tree2);
 156 
        subtreesOfY.add(tree2);
157 
 
 157 
 
158 
		//create treeY
 158 
        //create treeY
159 
		UnorderedTree treeY = new UnorderedTree("Y",subtreesOfY);
 159 
        UnorderedTree treeY = new UnorderedTree("Y",subtreesOfY);
160 
 
 160 
 
161 
		//create subtrees of 4
 161 
        //create subtrees of 4
162 
		Set subtreesOf4 = new HashSet();
 162 
        Set subtreesOf4 = new HashSet();
163 
		subtreesOf4.add(treeN);
 163 
        subtreesOf4.add(treeN);
164 
 
 164 
 
165 
		//create tree4
 165 
        //create tree4
166 
		UnorderedTree tree4 = new UnorderedTree("4",subtreesOf4);
 166 
        UnorderedTree tree4 = new UnorderedTree("4",subtreesOf4);
167 
 
 167 
 
168 
		//create subtrees of E
 168 
        //create subtrees of E
169 
		Set subtreesOfE = new HashSet();
 169 
        Set subtreesOfE = new HashSet();
170 
		subtreesOfE.add(tree3);
 170 
        subtreesOfE.add(tree3);
171 
		subtreesOfE.add(treeD);
 171 
        subtreesOfE.add(treeD);
172 
 
 172 
 
173 
		//create treeE
 173 
        //create treeE
174 
		UnorderedTree treeE = new UnorderedTree("E",subtreesOfE);
 174 
        UnorderedTree treeE = new UnorderedTree("E",subtreesOfE);
175 
 
 175 
 
176 
		//create subtrees of L
 176 
        //create subtrees of L
177 
		Set subtreesOfL = new HashSet();
 177 
        Set subtreesOfL = new HashSet();
178 
		subtreesOfL.add(treeY);
 178 
        subtreesOfL.add(treeY);
179 
 
 179 
 
180 
		//create treeL
 180 
        //create treeL
181 
		UnorderedTree treeL = new UnorderedTree("L",subtreesOfL);
 181 
        UnorderedTree treeL = new UnorderedTree("L",subtreesOfL);
182 
 
 182 
 
183 
		//create subtrees of C
 183 
        //create subtrees of C
184 
		Set subtreesOfC = new HashSet();
 184 
        Set subtreesOfC = new HashSet();
185 
		subtreesOfC.add(tree4);
 185 
        subtreesOfC.add(tree4);
186 
		subtreesOfC.add(treeE);
 186 
        subtreesOfC.add(treeE);
187 
 
 187 
 
188 
		//create treeC
 188 
        //create treeC
189 
		UnorderedTree treeC = new UnorderedTree("C",subtreesOfC);
 189 
        UnorderedTree treeC = new UnorderedTree("C",subtreesOfC);
190 
 
 190 
 
191 
		//create subtrees of G
 191 
        //create subtrees of G
192 
		Set subtreesOfG = new HashSet();
 192 
        Set subtreesOfG = new HashSet();
193 
		subtreesOfG.add(treeF);
 193 
        subtreesOfG.add(treeF);
194 
 
 194 
 
195 
		//create treeG
 195 
        //create treeG
196 
		UnorderedTree treeG = new UnorderedTree("G",subtreesOfG);
 196 
        UnorderedTree treeG = new UnorderedTree("G",subtreesOfG);
197 
 
 197 
 
198 
		//create subtrees of J
 198 
        //create subtrees of J
199 
		Set subtreesOfJ = new HashSet();
 199 
        Set subtreesOfJ = new HashSet();
200 
		subtreesOfJ.add(treeK);
 200 
        subtreesOfJ.add(treeK);
201 
		subtreesOfJ.add(treeL);
 201 
        subtreesOfJ.add(treeL);
202 
		subtreesOfJ.add(treeM);
 202 
        subtreesOfJ.add(treeM);
203 
 
 203 
 
204 
		//create treeJ
 204 
        //create treeJ
205 
		UnorderedTree treeJ = new UnorderedTree("J",subtreesOfJ);
 205 
        UnorderedTree treeJ = new UnorderedTree("J",subtreesOfJ);
206 
 
 206 
 
207 
		//create subtrees of B
 207 
        //create subtrees of B
208 
		Set subtreesOfB = new HashSet();
 208 
        Set subtreesOfB = new HashSet();
209 
		subtreesOfB.add(treeC);
 209 
        subtreesOfB.add(treeC);
210 
		subtreesOfB.add(treeG);
 210 
        subtreesOfB.add(treeG);
211 
 
 211 
 
212 
		//create treeB
 212 
        //create treeB
213 
		UnorderedTree treeB = new UnorderedTree("B",subtreesOfB);
 213 
        UnorderedTree treeB = new UnorderedTree("B",subtreesOfB);
214 
 
 214 
 
215 
		//create subtrees of H
 215 
        //create subtrees of H
216 
		Set subtreesOfH = new HashSet();
 216 
        Set subtreesOfH = new HashSet();
217 
		subtreesOfH.add(treeI);
 217 
        subtreesOfH.add(treeI);
218 
		subtreesOfH.add(treeJ);
 218 
        subtreesOfH.add(treeJ);
219 
 
 219 
 
220 
		//create treeH
 220 
        //create treeH
221 
		UnorderedTree treeH = new UnorderedTree("H",subtreesOfH);
 221 
        UnorderedTree treeH = new UnorderedTree("H",subtreesOfH);
222 
 
 222 
 
223 
		//create subtrees of A
 223 
        //create subtrees of A
224 
		Set subtreesOfA = new HashSet();
 224 
        Set subtreesOfA = new HashSet();
225 
		subtreesOfA.add(treeB);
 225 
        subtreesOfA.add(treeB);
226 
		subtreesOfA.add(treeH);
 226 
        subtreesOfA.add(treeH);
227 
 
 227 
 
228 
		//create treeA
 228 
        //create treeA
229 
		UnorderedTree treeA = new UnorderedTree("A",subtreesOfA);
 229 
        UnorderedTree treeA = new UnorderedTree("A",subtreesOfA);
230
230
231 
		//return the completed tree
 231 
        //return the completed tree
232 
		return treeA;
 232 
        return treeA;
233 
	}
 233 
    }
234
234
235 
} //end of class Driver
 235 
} //end of class Driver
236 
 
 236