Binary Search Tree Longest Path Take 2

LongestPathBST.java

/*
Interview Question:
Here's a binary tree: find the longest path within it.
So, find a path between any two leaf nodes, where the path is the longest.”
*/
 
public class TreeNode{
  int data;
  TreeNode left;
  TreeNode right;
  
  public TreeNode(int d){
      data = d;
      left = null;
      right = null;
  }
}
 
public class BinarySearchTree{
  
 TreeNode root;
 
 public BinarySearchTree{
  root = null;
 }

 public int getLongestPathInBST(){
   
   int[] arrLongestPath = new int[]{0};
   
   traverseTreeSearchLongestPath(root, arrLongestPath);
   
   return arrLongestPath[0];
 }
 
 private void traverseTreeSearchLongestPath(TreeNode node, int[] arrLongestPath){
   
   int longestPath = getLongestPathForNode(node);
   
   if (longestPath > arrLongestPath[0]){
     arrLongestPath[0] = longestPath;
   }
   
   traverseTreeSearchLongestPath(node.left, arrLongestPath);
   traverseTreeSearchLongestPath(node.right, arrLongestPath);
   
 }
 
 
 private int getLongestPathForNode(TreeNode node){
   if (node == null){
    return 0;
   }
   else if (node.left == null && node.right != null){
     //longest path is from current node
     return getLongestPathHelper(node.right, 1);
   }
   else if (node.left != null && node.right == null){
     //longest path is from current node
     return getLongestPathHelper(node.left, 1);
   }
   else{
     //longest path is between deepest node on the left side and deepest node on the right side
     return (getLongestPathHelper(root.left, 1) + getLongestPathHelper(root.right, 1));
   }
 }
 
 private int getLongestPathHelper(TreeNode node, int level){
   if (node.left == null && node.right == null){
     return level;
   }
   else{
     if (root.left == null && root.right != null){
       return getLongestPathHelper(root.right, level + 1);
     }
     else if (root.left != null && root.right == null){
       return getLongestPathHelper(root.left, level + 1);
     }
     else{
       int left = getLongestPathHelper(root.left, level + 1);
       int right = getLongestPathHelper(root.right, level + 1);
       return (right > left ? right : left)
     }
   }
 }
}