working out some tree tests.

trees/LinkedBinTree.java

@@ -206,6 +206,7 @@ public class LinkedBinTree<E> extends AbstractBinaryTree<E> {
 		}
 		Node<E> c = createNode(e, parent, null, null);
 		parent.setLeft(c);
+		size++;
 		return c;
 	}
 
@@ -217,6 +218,7 @@ public class LinkedBinTree<E> extends AbstractBinaryTree<E> {
 		}
 		Node<E> c = createNode(e, parent, null, null);
 		parent.setRight(c);
+		size++;
 		return c;
 	}
 
@@ -240,17 +242,42 @@ public class LinkedBinTree<E> extends AbstractBinaryTree<E> {
 		if(!t1.isEmpty()) {
 			t1.root.setParent(node);
 			node.setLeft(t1.root);
+			// empty out t1
 			t1.root = null;
 			t1.size = 0;
 		}
 		if(!t2.isEmpty()) { 
 			t2.root.setParent(node);
 			node.setRight(t2.root);
+			// empty out t2
 			t2.root = null;
 			t2.size = 0;
 		}
 	}
 
+
+
+	/** Prune the entire subtree rooted at position p. */
+	public void pruneSubtree(Position<E> p) { 
+		Node<E> node = validate(p);
+		node.setLeft(null);
+		node.setRight(null);
+
+		// how does an object commit suicide?
+		// what if something obscure points at the data?
+		if(!isRoot(p)) {
+			Node<E> par = parent(p);
+			if(par.getLeft()==p) { 
+				par.setLeft(null);
+			} else if(par.getRight()==p) { 
+				par.setRight(null);
+			}
+		}
+	}
+
+
+
+
 	/** Remove the node at position p and replace the node with its (single) child. 
 	 * Throws IllegalArgumentException if 2 children. 
 	 */

trees/TreeTesting.java

@@ -3,11 +3,60 @@ import java.util.Random;
 
 public class TreeTesting {
 
+	public static void banner(String title) { System.out.println("\n\n================ "+title+"\n\n"); }
+	
 	// Tests
 	public static void main(String[] args) { 
+		banner("Testing tree traversal.");
+		test_traversal();
+		banner("Testing tree attaching.");
+		test_attach();
+		banner("Testing tree removal.");
+		test_remove();
+	}
+
+
+
+
+	/** Generate a full tree and start paring some nodes down. */
+	public static void test_remove() {
+
 		LinkedBinTree<Integer> t = getFullTree(3);
 
-		// Traverse the tree in order.
+		System.out.println("Before:");
+		System.out.println("Tree size: " + t.size());
+		printPreorder(t, t.root(), 0);
+
+		Position<Integer> p = t.root.getLeft();
+		try {
+			t.remove(p);
+		} catch(IllegalArgumentException e) {
+			System.out.println("Caught an excepted exception.");
+			System.out.println("Can't remove nodes with >2 children... ambiguous.");
+		}
+
+		System.out.println("Pruning subtree.");
+
+		System.out.println("Before:");
+		printPreorder(t,t.root(), 0);
+
+		t.pruneSubtree(p);
+
+		System.out.println("After:");
+		printPreorder(t,t.root(), 0);
+		
+
+	}
+
+
+
+
+	/** Generate a full tree and traverse it a couple of ways. */
+	public static void test_traversal() {
+
+		LinkedBinTree<Integer> t = getFullTree(4);
+
+		// Traverse the tree in breadth-first order using the built-in BFT iterator.
 		System.out.println("Printing tree in breadth-first order:");
 		for(Position<Integer> p : t.bft()) {
 			System.out.print(spaces(t.depth(p)));
@@ -15,8 +64,47 @@ public class TreeTesting {
 			System.out.print("\n");
 		}
 
+		// Traverse the tree in pre-order using a custom-defined static recursive method (see below.)
 		System.out.println("Printing tree in pre-order:");
 		printPreorder(t, t.root(), 0);
+
+		System.out.println("Size of tree: " + t.size());
+
+		// Creating and traversing a tree 
+		// tests a surprising amount of the class.
+	}
+
+	/** Generate some big trees and attach them. */
+	public static void test_attach() { 
+
+		// Attach
+
+		LinkedBinTree<Integer> a = getFullTree(12);
+		LinkedBinTree<Integer> b = getFullTree(12);
+
+		int asize = a.size();
+		int bsize = b.size();
+
+		System.out.println("Size of Tree A: " + asize);
+		System.out.println("Size of Tree B: " + bsize);
+
+		LinkedBinTree<Integer> full = getFullTree(12);
+
+		int fullsize = full.size();
+		System.out.println("Size of FullTree before attach: " + fullsize);
+
+		for(Position<Integer> p : full.bft()) {
+			if(full.isExternal(p)) {
+				full.attach(p, a, b);
+			}
+		}
+		
+		System.out.println("Size of FullTree after attach: " + full.size());
+		System.out.println("(should match "+ (asize+bsize+fullsize) + ")");
+
+
+		System.out.println("Tree height: "+full.height());
+
 	}
 
 	/** Print the nodes in preorder.
@@ -36,6 +124,8 @@ public class TreeTesting {
 	/** Test method: get a full binary tree with n levels. */
 	public static LinkedBinTree<Integer> getFullTree(int n) {
 
+		int MAX = 100;
+
 		LinkedBinTree<Integer> t = new LinkedBinTree<Integer>();
 		Random r = new Random();
 
@@ -48,8 +138,8 @@ public class TreeTesting {
 				// the problem with interfaces is when you end up with a dozen files where it ::could:: be defined.
 				// grep to th e rescue.
 				if(t.isExternal(node)) {
-					Integer iL = new Integer( r.nextInt(n*n)-4*n  );
-					Integer iR = new Integer( r.nextInt(n*n)-4*n  );
+					Integer iL = new Integer( r.nextInt(MAX*MAX)-4*MAX  );
+					Integer iR = new Integer( r.nextInt(MAX*MAX)-4*MAX  );
 					t.addLeft(node,iL);
 					t.addRight(node,iR);
 				}
@@ -70,12 +160,6 @@ public class TreeTesting {
 		return s.toString();
 	}
 
-
-
-
-
-
-
 }