Print the longest leaf to leaf path in a binary tree

import java.util.HashMap;
import java.util.ArrayList;
/*
    Java Program
    Print the longest leaf to leaf path in a binary tree
*/
// Binary Tree node
class TreeNode
{
	public int data;
	public TreeNode left;
	public TreeNode right;
	public TreeNode(int data)
	{
		// Set node value
		this.data = data;
		this.left = null;
		this.right = null;
	}
}
class InternalNodeHeight
{
	public int left;
	public int right;
	public TreeNode parent;
	public InternalNodeHeight(int left, int right, TreeNode parent)
	{
		// height of left subtree
		this.left = left;
		// height of right subtree
		this.right = right;
		// root of left and right subtree
		this.parent = parent;
	}
}
public class BinaryTree
{
	public TreeNode root;
	public BinaryTree()
	{
		// Set initial tree root to null
		this.root = null;
	}
	// Finding height of all internal nodes in binary tree using recursion
	public int fingHeight(TreeNode node, HashMap < Integer, 
                           InternalNodeHeight > record)
	{
		if (node == null)
		{
			return 0;
		}
		else if (node.left == null && node.right == null)
		{
			// When node is leaf node
			return 1;
		}
		// Height of left subtree
		int l = fingHeight(node.left, record);
		// Height of right subtree
		int r = fingHeight(node.right, record);
		if (node.left != null && node.right != null)
		{
			// Store height of internal node when not exist
			if (!record.containsKey(l + r))
			{
				// Add new internal node height
				InternalNodeHeight height = new InternalNodeHeight(l, r, node);
				record.put(l + r, height);
			}
		}
		if (l > r)
		{
			return l + 1;
		}
		else
		{
			return r + 1;
		}
	}
	// Display given path from bottom to top direction
	public void pathBottomToTop(ArrayList < Integer > path)
	{
		int i = path.size() - 1;
		// print path
		while (i >= 0)
		{
			System.out.print(" " + path.get(i));
			i--;
		}
	}
	// Display given path from top to bottom direction
	public void pathTopToBottom(ArrayList < Integer > path)
	{
		int i = 0;
		// print path
		while (i < path.size())
		{
			System.out.print(" " + path.get(i));
			i++;
		}
	}
	// Find the first longest leaf path of which is exist in given node
	public boolean findPath(TreeNode node, int height, 
                             ArrayList < Integer > path)
	{
		if (node == null)
		{
			return false;
		}
		// Add path element
		path.add(node.data);
		if (height == 0)
		{
			if (node.left == null && node.right == null)
			{
				// Getting the path of first leaf node in given height
				return true;
			}
			return false;
		}
		else if (findPath(node.left, height - 1, path) 
                 || findPath(node.right, height - 1, path))
		{
			// When path found
			return true;
		}
		// Remove last path node
		path.remove(path.size() - 1);
		return false;
	}
	// Handles the request of finding longest leaf to leaf path in tree
	public void longestLeafToLeaf()
	{
		// Use to collect height of internal node
		HashMap < Integer, InternalNodeHeight > record = 
          new HashMap < Integer, InternalNodeHeight > ();
		// This is use to collect leaf node path
		ArrayList < Integer > path = new ArrayList < Integer > ();
		// Calculate height of internal node
		fingHeight(this.root, record);
		int height = 0;
		InternalNodeHeight auxiliary = null;
		// Find a node which are longest path two leaf nodes
		for (int key: record.keySet())
		{
			if (key > height)
			{
				height = key;
				// Get the resultant parent node
				auxiliary = record.get(key);
			}
		}
		if (height == 0 || auxiliary == null)
		{
			// When no more than one leaf nodes
			return;
		}
		else
		{
			// Find first leaf node path
			findPath(auxiliary.parent.left, auxiliary.left - 1, path);
			// Print first leaf node path
			pathBottomToTop(path);
			// Print ancestor node value
			System.out.print(" " + auxiliary.parent.data);
			path.clear();
			// Find Second leaf node path
			findPath(auxiliary.parent.right, auxiliary.right - 1, path);
			// Print Second leaf node path
			pathTopToBottom(path);
			System.out.print("\n");
		}
	}
	public static void main(String[] args)
	{
		// Create new binary tree
		BinaryTree tree1 = new BinaryTree();
		BinaryTree tree2 = new BinaryTree();
		/*
		         4                            
		       /   \    
		     -4     7    
		     / \     \               
		    2   3     12
		       / \    / 
		      10  8  5
		      /       \
		     9         15 
		-----------------
		Constructing binary tree
		                
		        
		*/
		tree1.root = new TreeNode(4);
		tree1.root.left = new TreeNode(-4);
		tree1.root.left.right = new TreeNode(3);
		tree1.root.left.right.left = new TreeNode(10);
		tree1.root.left.right.left.left = new TreeNode(9);
		tree1.root.left.right.right = new TreeNode(8);
		tree1.root.left.left = new TreeNode(2);
		tree1.root.right = new TreeNode(7);
		tree1.root.right.right = new TreeNode(12);
		tree1.root.right.right.left = new TreeNode(5);
		tree1.root.right.right.left.right = new TreeNode(15);
		// Case 1
		tree1.longestLeafToLeaf();
		/*
		         4                            
		       /   \    
		     -4     7    
		     / \                   
		    2   3     
		       / \     
		      10  8  
		     /     \   
		    9       1
		   /         \
		  6           5    
		-----------------
		Constructing binary tree 2
		                
		        
		*/
		tree2.root = new TreeNode(4);
		tree2.root.left = new TreeNode(-4);
		tree2.root.left.right = new TreeNode(3);
		tree2.root.left.right.left = new TreeNode(10);
		tree2.root.left.right.left.left = new TreeNode(9);
		tree2.root.left.right.left.left.left = new TreeNode(6);
		tree2.root.left.right.right = new TreeNode(8);
		tree2.root.left.right.right.right = new TreeNode(1);
		tree2.root.left.right.right.right.right = new TreeNode(5);
		tree2.root.left.left = new TreeNode(2);
		tree2.root.right = new TreeNode(7);
		// Case 2
		tree2.longestLeafToLeaf();
	}
}

input

 9 10 3 -4 4 7 12 5 15
 6 9 10 3 8 1 5