Find direction of path followed from root by a linked list in a Binary Tree

// C# program for the above approach
using System;
using System.Collections.Generic;

public class GFG{

class ListNode {
    public int data;
    public ListNode next;
    public ListNode(int data)
    {
        this.data = data;
        this.next = null;
    }
};

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

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

// Function to create the Linked list
static ListNode makeList(int []arr, int n)
{
    ListNode h = null;
    ListNode root = new ListNode(0);
    for (int i = 0; i < n; i++) {
        int data = arr[i];
        ListNode node = new ListNode(data);

        if (h == null) {
            h = node;
            root = h;
        }
        else {
            root.next = node;
            root = node;
        }
    }
    return h;
}

// utility function to build tree
// from its level order traversal
static TreeNode build_tree(int []nodes, int n)
{
    TreeNode root = new TreeNode(nodes[0]);
    Queue<TreeNode> q = new Queue<TreeNode>();
    bool is_left = true;
    TreeNode cur = null;
    q.Enqueue(root);

    for (int i = 1; i < n; i++) {
        TreeNode node = null;
        if (nodes[i] != 0) {
            node = new TreeNode(nodes[i]);
            q.Enqueue(node);
        }

        if (is_left) {
            cur = q.Peek();
            q.Dequeue();
            cur.left = node;
            is_left = false;
        }
        else {
            cur.right = node;
            is_left = true;
        }
    }

    return root;
}

// Function to find path of linked list
// in binary tree, by traversing the
// tree in pre-order fashion
static bool findPath(TreeNode root, ListNode head,
              List<char> path)
{
  
    // Base Case
    if (root == null) {
        return false;
    }

    // If current tree node is not same
    // as the current LL Node, then
    // return False
    if (root.val != head.data)
        return false;

    // Complete the path of LL is traced
    if (root.left == null
        && root.right == null
        && head.next == null) {
        return true;
    }

    // First go to left
    path.Add('L');

    // If path found in left subtree
    if (findPath(root.left,
                 head.next, path))
        return true;

    // Pop L because valid path is
    // not traced
    path.RemoveAt(path.Count-1);

    // Go to right
    path.Add('R');

    // If path found in right subtree
    if (findPath(root.right,
                 head.next, path))
        return true;

    // Pop R because valid path
    // is not traced
    path.RemoveAt(path.Count-1);

    return false;
}

// Function to find the valid path
static void find(TreeNode root, ListNode head)
{
    List<char> path = new List<char>();

    // Function call to find the direction
    // of the LL path
    findPath(root, head, path);

    // If there doesn't exists any
    // such paths
    if (path.Count == 0) {
        Console.Write("-1");
        return;
    }

    // Print the path
    for (int i = 0;
         i < path.Count; i++) {
        Console.Write(path[i]+ " ");
    }
}

// Driver Code
public static void Main(String[] args)
{
    int []tree = { 1, 2, 3, 4, 5, 6,
                   8, -1, -1, 8 };
    TreeNode root = build_tree(tree, 10);

    int []ll = { 1, 2, 5, 8 };
    ListNode head = makeList(ll, 4);

    find(root, head);

}
}

// This code is contributed by 29AjayKumar