Deepest node in tree
Your braces do not follow the Standard Java Conventions. The standard way is:

public BinaryTree(E data, BinaryTree&lt;E&gt; leftNode, BinaryTree&lt;E&gt; rightNode) {
    this.data = data;
    this.leftNode = leftNode;
    this.rightNode = rightNode;
}


Notice the movement of the braces.

You should have a constructor for your BinaryTree that takes no parameters and one that takes only the data:

public BinaryTree() {

}

public BinaryTree(E data) {
    this.data = data;
}

public BinaryTree(E data, BinaryTree&lt;E&gt; leftNode, BinaryTree&lt;E&gt; rightNode) {
    this.data = data;
    this.leftNode = leftNode;
    this.rightNode = rightNode;
}


This way, programmers using it has a choice of being able to give less information, and add it later through the set() methods. Also, this allows them to prevent them from doing stuff like:

BinaryTree&lt;Integer&gt; tree = new BinaryTree&lt;Integer&gt;(null, null, null);


After all, who wants to do that?

I don't see any point in making a separate class for finding the deepest node int the tree. Why not just put it under one class?

There is a better way to do it with recursion:

public BinaryTree&lt;E&gt; getDeepestNode(BinaryTree&lt;E&gt; rootNode) {
    if (rootNode.leftNode.isLeafNode() &amp;&amp; rootNode.rightNode.isLeafNode()) {
        return rootNode;
    }
    return getDeepestNode(rootNode.getLeftNode(), 0) &gt; getDeepestNode(
            rootNode.getRightNode(), 0) ? getDeepestNode(rootNode
            .getLeftNode()) : getDeepestNode(rootNode.getRightNode());
}

private int getDeepestNode(BinaryTree&lt;E&gt; rootNode, int depth) {
    if (rootNode.leftNode.isLeafNode() &amp;&amp; rootNode.rightNode.isLeafNode()) {
        return depth + 1;
    }
    return getDeepestNode(rootNode, depth + 1);
}


I know you wanted it without recursion, but I only came up with a solution by using recursion. If you really don't want to use recursion, then your code is fine.