Need help with one of my java classes :

Import bridges.base.BSTElement to allow you to use BSTElement objects

- Replace every instance and operation of the BinNode class with a BSTElement object and its equivalent methods

- Add methods to perform each type of traversal: preorder, postorder, inorder

- Add a method to count the number of leaf nodes and assign each a particular color or opacity

- Add a method to count the number of internal nodes and assign each a particular color or opacity

- Add a method to count the number of nodes with two children and assign each a particular color or opacity

- Add a method to determine the height of the tree (the longest path length)

Java Code :

import bridges.connect.Bridges; import bridges.base.BSTElement;

/** Binary Search Tree implementation for Dictionary ADT */ class BST, E> implements Dictionary { private BSTNode root; // Root of the BST private int nodecount; // Number of nodes in the BST /** Constructor */ BST() { root = null; nodecount = 0; } /** Reinitialize tree */ public void clear() { root = null; nodecount = 0; } /** Insert a record into the tree. @param k Key value of the record. @param e The record to insert. */ public void insert(Key k, E e) { root = inserthelp(root, k, e); nodecount++; } /** @return The current subtree, modified to contain the new item */ private BSTNode inserthelp(BSTNode rt, Key k, E e) { if (rt == null) return new BSTNode(k, e); if (rt.key().compareTo(k) > 0) rt.setLeft(inserthelp(rt.left(), k, e)); else rt.setRight(inserthelp(rt.right(), k, e)); return rt; } /** Remove a record from the tree. @param k Key value of record to remove. @return The record removed, null if there is none. */ public E remove(Key k) { E temp = findhelp(root, k); // First find it if (temp != null) { root = removehelp(root, k); // Now remove it nodecount--; } return temp; } /** Remove and return the root node from the dictionary. @return The record removed, null if tree is empty. */ public E removeAny() { if (root == null) return null; E temp = root.element(); root = removehelp(root, root.key()); nodecount--; return temp; } /** Remove a node with key value k @return The tree with the node removed */ private BSTNode removehelp(BSTNode rt,Key k) { if (rt == null) return null; if (rt.key().compareTo(k) > 0) rt.setLeft(removehelp(rt.left(), k)); else if (rt.key().compareTo(k) < 0) rt.setRight(removehelp(rt.right(), k)); else { // Found it if (rt.left() == null) return rt.right(); else if (rt.right() == null) return rt.left(); else { // Two children BSTNode temp = getmin(rt.right()); rt.setElement(temp.element()); rt.setKey(temp.key()); rt.setRight(deletemin(rt.right())); } } return rt; } private BSTNode deletemin(BSTNode rt) { if (rt.left() == null) return rt.right(); rt.setLeft(deletemin(rt.left())); return rt; } private BSTNode getmin(BSTNode rt) { if (rt.left() == null) return rt; return getmin(rt.left()); } /** @return Record with key value k, null if none exist. @param k The key value to find. */ public E find(Key k) { return findhelp(root, k); } private E findhelp(BSTNode rt, Key k) { if (rt == null) return null; if (rt.key().compareTo(k) > 0) return findhelp(rt.left(), k); else if (rt.key().compareTo(k) == 0) return rt.element(); else return findhelp(rt.right(), k); } /** @return The number of records in the dictionary. */ public int size() { return nodecount; }

/** Inorder Traversal */ public void inorder() { inorderHelp( root ); } private void inorderHelp( BSTNode r ) { return; } /** Postorder Traversal */ public void postorder() { postorderHelp( root ); } private void postorderHelp( BSTNode r ) { return; } /** Preorder Traversal */ public void preorder() { preorderHelp( root ); } private void preorderHelp( BSTNode r ) { return; } /** Count the number of leaf nodes */ public Integer countLeaves() { return countLeafHelp( root ); } private Integer countLeafHelp( BSTNode r ) { return -1; } /** Count the number of internal nodes */ public Integer countInternalNodes() { return countInternalNodes( root ); } private Integer countInternalNodes( BSTNode r ) { return -1; } /** Count the nodes with two children */ public Integer countTwoChildNodes() { return twoChildHelp( root ); } private Integer twoChildHelp( BSTNode r ) { return -1; } /** Compute the max path length */ public Integer getMaxPathLength() { return maxPathHelp( root ); } private Integer maxPathHelp( BSTNode r ) { return -1; }

}