Step by step Shortest Path from source node to destination node in a Binary Tree

// Java program for above approach

class TreeNode {
    int val;
    TreeNode left;
    TreeNode right;

    TreeNode(int x)
    {
        val = x;
        left = null;
        right = null;
    }
}

// Function to find LCA of two nodes
class Solution {
    TreeNode lca(TreeNode root, int startValue,
                 int destValue)
    {
        // Base Case
        if (root == null) {
            return null;
        }

        if (root.val == startValue) {
            return root;
        }
        if (root.val == destValue) {
            return root;
        }

        TreeNode l = lca(root.left, startValue, destValue);
        TreeNode r = lca(root.right, startValue, destValue);

        if (l != null && r != null) {
            return root;
        }

        return l != null ? l : r;
    }

    boolean getPath(TreeNode root, int value,
                    StringBuilder path)
    {
        // Base Cases
        if (root == null) {
            return false;
        }
        if (root.val == value) {
            return true;
        }

        path.append("L");
        boolean res = getPath(root.left, value, path);
        if (res) {
            return true;
        }
        path.deleteCharAt(path.length() - 1);
        path.append("R");
        res = getPath(root.right, value, path);
        if (res) {
            return true;
        }
        path.deleteCharAt(path.length() - 1);
        return false;
    }

    // Function to get directions
    String getDirections(TreeNode root, int startValue,
                         int destValue)
    {
        // Find the LCA first
        root = lca(root, startValue, destValue);

        StringBuilder p1 = new StringBuilder();
        StringBuilder p2 = new StringBuilder();

        // Get the path
        getPath(root, startValue, p1);
        getPath(root, destValue, p2);
        for (int i = 0; i < p1.length(); i++) {
            p1.setCharAt(i, 'U');
        }

        // Return the concatenation
        return p1.append(p2).toString();
    }
}

// Driver Code
public class Main {
    public static void main(String[] args)
    {
        /*
             5
           /    \
         1       2
        /       /  \
      3        6    4

       */
        TreeNode root = new TreeNode(5);
        root.left = new TreeNode(1);
        root.right = new TreeNode(2);
        root.left.left = new TreeNode(3);
        root.right.left = new TreeNode(6);
        root.right.right = new TreeNode(4);

        int startValue = 3;
        int endValue = 6;

        // Function Call
        Solution solution = new Solution();
        String ans = solution.getDirections(
            root, startValue, endValue);

        // Print answer
        System.out.println(ans);
    }
}

// Java Code
import java.util.ArrayList;

class TreeNode {
    int val;
    TreeNode left;
    TreeNode right;

    TreeNode(int val2)
    {
        this.val = val2;
        this.left = null;
        this.right = null;
    }
}

class solution {
    // Find Function
    public static boolean find(TreeNode n, int val,
                               ArrayList<String> path)
    {
        if (n.val == val) {
            return true;
        }
        if (n.left != null && find(n.left, val, path)) {
            path.add("R");
            return true;
        }
        if (n.right != null && find(n.right, val, path)) {
            path.add("L");
            return true;
        }
        return false;
    }

    // Function to keep track of directions at any point
    public static ArrayList<String>
    getDirections(TreeNode root, int startValue,
                  int destValue)
    {
        // To store the startPath and destPath
        ArrayList<String> s_p = new ArrayList<>();
        ArrayList<String> d_p = new ArrayList<>();
        find(root, startValue, s_p);
        find(root, destValue, d_p);

        while (s_p.size() > 0 && d_p.size() > 0
               && s_p.get(s_p.size() - 1)
                      .equals(d_p.get(d_p.size() - 1))) {
            s_p.remove(s_p.size() - 1);
            d_p.remove(d_p.size() - 1);
        }

        for (int i = 0; i < s_p.size(); i++) {
            s_p.set(i, "U");
        }
        //Collections.reverse(d_p);
        ArrayList<String> ans = new ArrayList<>(s_p);
        ans.addAll(d_p);
        return ans;
    }

    public static void main(String[] args)
    {
        TreeNode root = new TreeNode(5);
        root.left = new TreeNode(1);
        root.right = new TreeNode(2);
        root.left.left = new TreeNode(3);
        root.right.left = new TreeNode(6);
        root.right.right = new TreeNode(4);

        int startValue = 3;
        int endValue = 6;

        ArrayList<String> ans
            = getDirections(root, startValue, endValue);
        System.out.println(ans);
    }
}