I have a binary tree. Amongst all the furthest nodes from the root (Height of the tree I believe), I need to find the furthest to the right of those nodes.

Example 1:

```
      M
     / \
    G   N
   / \   \
  D   H   O
 / \       \
B   F       Q

```

The furthest to the right amongst the furthest nodes from the root is 'Q'.

Example 2:

```
      M
     / \
    G   N
   / \   \
  D   H   O
 / \       
B   F       

```

The furthest to the right amongst the furthest nodes from the root is 'F'.

The code I have can get deepest node and return the rightmost node (left if deepest node has no right children). But then I ran into a issue where there could be leaves of the same size and I didn't know how to back track and compare all of them to find the furtherest (which in this case would be 'Q')

I found out how to find the max height of the tree, but not how to implement that into my code

This is what I have thus far:

```
public void find(Node<T> r) {   

    if(r.right == null) { // Are there any children to the right?
        if(r.left.size() > 1) {
            find(r.left); // If not, we go left if there are more than 1
        }

        if(r.left.size() == 1) { //
            rNode = r.left.data;
        }

    }

    if(r.left == null) { // Are there any children to the left?
        if(r.right.size() > 1) {
            find(r.right); // If not, we go right if there are more than 1
        }

        if(r.right.size() == 1) {
            rNode = r.right.data; // If the right is the only node left, pick it as the answer
        }
    }

    if(r.left != null && r.right != null) { // Are there children to the left and right?
        if(r.left.size() == r.right.size()) { // 
            if(r.left.size() == 1) { // If we have 1 child to the right and left, pick the right child
                rNode = r.left.data; // If the left is the only node left, pick it as the answer
            } 
        }

        if(r.left.size() > r.right.size()) { // Are there more to the left?
            find(r.left); // Proceed
        }

        if(r.left.size() < r.right.size()) { // Are there more to the right?
            find(r.right); // Proceed
        }
    } 

}

public int maxDepth(Node<T> r) {

     if(r == null){
         return 0;
     }

     int leftDepth = maxDepth(r.left);
     int rightDepth = maxDepth(r.right);

     return Math.max(leftDepth, rightDepth)+1;     
 }

/**
 * Among all the nodes which are farthest from the root, find the one which is
 * farthest to the right.
 * 
 * @return data value of said node
 */
public T findRightmostLowest() {
    if(root.size() == 1) return root.data;

    find(root);
    return rNode;
}

```