Having trouble finding the height of a Binary Tree

Question

Hi, I have an ADT class called DigitalTree that uses Nodes to form a binary tree; each subtree only has two children at most. Each node has a "key" that is just a long value and is placed in the correct position on the tree determined by its binary values. For the height, I'm having trouble getting an accurate height. With the data I'm using, I should get a height of 5 (I use an array of 9 values/nodes, in a form that creates a longest path of 5. The data I use is int[] ar = {75, 37, 13, 70, 75, 90, 15, 13, 2, 58, 24} ). Here is my code for the whole tree. If someone could provide some tips or clues to help me obtain the right height value, or if you see anything wrong with my code, it would be greatly aprpeciated. Thanks!
public class DigitalTree<E> implements Copyable
   private Node root;
   private int size;
   public DigitalTree()
       root = null;
       size = 0;
   public boolean add(long k)
       if(!contains(k))
            if(this.size == 0)
                root = new Node(k);
                size++;
                System.out.println(size + " " + k);
            else
                String bits = Long.toBinaryString(k);
                //System.out.println(bits);
                return add(k, bits, bits.length(), root);
            return true;
       else
           return false;
   private boolean add(long k, String bits, int index, Node parent)
       int lsb;
       try
           lsb = Integer.parseInt(bits.substring(index, index - 1));
       catch(StringIndexOutOfBoundsException e)
           lsb = 0;
       if(lsb == 0)
           if(parent.left == null)
               parent.left = new Node(k);
               size++;
               //System.out.println(size + " " + k);
               return true;
           else
               return add(k, bits, index-1, parent.left);
       else
           if(parent.right == null)
               parent.right = new Node(k);
               size++;
               //System.out.println(size + " " + k);
               return true;
           else
               return add(k, bits, index-1,  parent.right);
   public int height()
       int leftHeight = 0, rightHeight = 0;
       return getHeight(root, leftHeight, rightHeight);
   private int getHeight(Node currentNode, int leftHeight, int rightHeight)
       if(currentNode == null)
           return 0;
       //else
       //    return 1 + Math.max(getHeight(currentNode.right), getHeight(currentNode.left));
       if(currentNode.left == null)
           leftHeight = 0;
       else
           leftHeight = getHeight(currentNode.left, leftHeight, rightHeight);
       if(currentNode.right == null)
           return 1 + leftHeight;
       return 1 + Math.max(leftHeight, getHeight(currentNode.right, leftHeight, rightHeight));
   public int size()
       return size;
   public boolean contains(long k)
        String bits = Long.toBinaryString(k);
        return contains(k, root, bits, bits.length());
   private boolean contains(long k, Node currentNode, String bits, int index)
       int lsb;
       try
           lsb = Integer.parseInt(bits.substring(index, index - 1));
       catch(StringIndexOutOfBoundsException e)
           lsb = 0;
       if(currentNode == null)
           return false;
       else if(currentNode.key == k)
           return true;
       else
           if(lsb == 0)
               return contains(k, currentNode.left, bits, index-1);
           else
               return contains(k, currentNode.right, bits, index-1);
   public Node locate(long k)
        if(contains(k))
            String bits = Long.toBinaryString(k);
            return locate(k, root, bits, bits.length());
        else
            return null;
   private Node locate(long k, Node currentNode, String bits, int index)
       int lsb;
       try
           lsb = Integer.parseInt(bits.substring(index, index - 1));
       catch(StringIndexOutOfBoundsException e)
           lsb = 0;
       if(currentNode.key == k)
           return currentNode;
       else
           if(lsb == 0)
               return locate(k, currentNode.left, bits, index-1);
           else
               return locate(k, currentNode.right, bits, index-1);
   public Object clone()
       DigitalTree<E> treeClone = null;
       try
           treeClone = (DigitalTree<E>)super.clone();
       catch(CloneNotSupportedException e)
           throw new Error(e.toString());
       cloneNodes(treeClone, root, treeClone.root);
       return treeClone;
   private void cloneNodes(DigitalTree treeClone, Node currentNode, Node cloneNode)
       if(treeClone.size == 0)
           cloneNode = null;
           cloneNodes(treeClone, currentNode.left, cloneNode.left);
           cloneNodes(treeClone, currentNode.right, cloneNode.right);
       else if(currentNode != null)
           cloneNode = currentNode;
           cloneNodes(treeClone, currentNode.left, cloneNode.left);
           cloneNodes(treeClone, currentNode.right, cloneNode.right);
   public void printTree()
       System.out.println("Tree");
   private class Node<E>
      private long key;
      private E data;
      private Node left;
      private Node right;
      public Node(long k)
         key = k;
         data = null;
         left = null;
         right = null;
      public Node(long k, E d)
         key = k;
         data = d;
         left = null;
         right = null;
      public String toString()
         return "" + key;
}

Answer 1

You were on the right track with the part you commented out; first define a few things:
1) the height of an empty tree is nul (0);
2) the height of a tree is one more than the maximum of the heights of the left and right sub-trees.
This translates to Java as a recursive function like this:
int getHeight(Node node) {
   if (node == null) // definition #1
      return 0;   
   else // definition #2
      return 1+Math.max(getHeight(node.left), getHeight(node.right));
}kind regards,
Jos