Miscellany

public abstract class BinaryTree
{

    public abstract boolean lessThan(Object left, Object right);
    public abstract boolean greaterThan (Object left, Object right);
    public abstract boolean equal(Object left, Object right);
    public abstract boolean notEqual(Object left, Object right);
    
    
 
    public BinaryTree()
    {
        root = null;
        size = 0;
    }



    public boolean nameExists(String name)
    {

        if ( root == null )
        return false;
        

        BinaryTreeNode nameLocationInTree = (nameLocation(name, false))[0];
        

        return (nameLocationInTree != null);
    
    }



    public void insert (String withName, int number) 
    {

        if (root == null)
        {
            root = new BinaryTreeNode(withName, number);
        }
        
        else           {
            BinaryTreeNode[] tempNodeAndParent =  nameLocation(withName,false);
            BinaryTreeNode insertedNode = tempNodeAndParent[0];
            BinaryTreeNode parentNode = tempNodeAndParent[1];
            

            
            insertedNode = new BinaryTreeNode(withName, number);
            
            if (lessThan(withName, parentNode.getName()))
                parentNode.setLeftChild(insertedNode);
            else
                parentNode.setRightChild(insertedNode);
            
        }
        size++;
    }


    public int size ()
    {
        return size;
    }


    protected BinaryTreeNode[] nameLocation(String name, boolean createIfNonExistent)
    {
        BinaryTreeNode currentNode = root;
        BinaryTreeNode currentNodesParent = currentNode;
        
        while ((currentNode != null) && (notEqual(currentNode.getName(),name)))
        {
            currentNodesParent = currentNode;
            
            if (lessThan(name,currentNode.getName()))
                currentNode = currentNode.getLeftChild();
            else
                currentNode = currentNode.getRightChild();
        }
        
        if ((currentNode == null) && createIfNonExistent)
        {
            currentNode = new BinaryTreeNode(name,1);
            
            if (lessThan(name,currentNodesParent.getName()))
                currentNodesParent.setLeftChild (currentNode);
            else
                currentNodesParent.setRightChild (currentNode);
        }
        
        BinaryTreeNode[] nodeAndParent = new BinaryTreeNode[2];
        nodeAndParent[0] = currentNode;
        nodeAndParent[1] = currentNodesParent;
        return (nodeAndParent);
    }

    protected BinaryTreeNode root;
    protected int size;
    private long uniqueNum = 0;
}