Create Binary Tree from given Array of relation between nodes

// C# code for the above approach:
using System;
using System.Collections.Generic;
using System.Linq;

// Binary Tree Node
class Node {
  public int data;
  public Node left, right;

  public Node(int data)
  {
    this.data = data;
    this.left = null;
    this.right = null;
  }
}

public class GFG {

  // Returns new Node with data as input
  // to below function.
  static Node NewNode(int data)
  {
    Node temp = new Node(data);
    temp.left = null;
    temp.right = null;
    return temp;
  }

  // Function to create tree from
  // given description
  static Node
    CreateBinaryTree(List<List<int> > descriptions)
  {
    Dictionary<int, Node> mp
      = new Dictionary<int, Node>();
    foreach(List<int> it in descriptions)
    {
      Node parentNode, childNode;

      // Check if the parent Node is
      // already formed or not
      if (mp.ContainsKey(it[0])) {
        parentNode = mp[it[0]];
      }
      else {
        parentNode = NewNode(it[0]);
        mp[it[0]] = parentNode;
      }

      // Check if the child Node is
      // already formed or not
      if (mp.ContainsKey(it[1])) {
        childNode = mp[it[1]];
      }
      else {
        childNode = NewNode(it[1]);
        mp[it[1]] = childNode;
      }

      // Making the Edge Between parent
      // and child Node
      if (it[2] == 1) {
        parentNode.left = childNode;
      }
      else {
        parentNode.right = childNode;
      }
    }

    // Store the childNode
    Dictionary<int, int> storeChild
      = new Dictionary<int, int>();
    foreach(List<int> it in descriptions)
    {
      storeChild[it[1]] = 1;
    }

    // Find the root of the Tree
    Node root = null;
    foreach(List<int> it in descriptions)
    {
      if (!storeChild.ContainsKey(it[0])) {
        root = mp[it[0]];
      }
    }
    return root;
  }

  // Level order Traversal
  static void PrintLevelOrder(Node root)
  {
    // Base Case
    if (root == null) {
      return;
    }

    // Create an empty queue for
    // level order traversal
    Queue<Node> q = new Queue<Node>();

    // Enqueue Root and initialize height
    q.Enqueue(root);
    while (q.Count > 0) {
      // Print front of queue and
      // remove it from queue
      Node node = q.Peek();
      Console.Write(node.data + " ");
      q.Dequeue();

      // Enqueue left child
      if (node.left != null) {
        q.Enqueue(node.left);
      }

      // Enqueue right child
      if (node.right != null) {
        q.Enqueue(node.right);
      }
    }
  }

  static public void Main()
  {
    List<List<int> > RelationArray
      = new List<List<int> >{
      new List<int>{ 20, 15, 1 },
      new List<int>{ 20, 17, 0 },
      new List<int>{ 50, 20, 1 },
      new List<int>{ 50, 80, 0 },
      new List<int>{ 80, 19, 1 }
    };
    Node root = CreateBinaryTree(RelationArray);
    PrintLevelOrder(root);
    Console.WriteLine();
    List<List<int> > RelationArray2
      = new List<List<int> >{
      new List<int>{ 1, 2, 1 },
      new List<int>{ 2, 3, 0 },
      new List<int>{ 3, 4, 1 }
    };
    Node root2 = CreateBinaryTree(RelationArray2);
    PrintLevelOrder(root2);
  }
}

// This code is contributed by lokesh.