1import java.util.*;
2
3class TreeNode {
4    int val;
5    TreeNode left;
6    TreeNode right;
7    TreeNode(int val) { this.val = val; }
8}
9
10class Solution {
11    public TreeNode createBinaryTree(int[][] descriptions) {
12        Map<Integer, TreeNode> nodeMap = new HashMap<>();
13        Set<Integer> children = new HashSet<>();
14
15        for (int[] desc : descriptions) {
16            int parent = desc[0], child = desc[1], isLeft = desc[2];
17            nodeMap.putIfAbsent(parent, new TreeNode(parent));
18            nodeMap.putIfAbsent(child, new TreeNode(child));
19
20            if (isLeft == 1) {
21                nodeMap.get(parent).left = nodeMap.get(child);
22            } else {
23                nodeMap.get(parent).right = nodeMap.get(child);
24            }
25
26            children.add(child);
27        }
28
29        for (int key : nodeMap.keySet()) {
30            if (!children.contains(key)) {
31                return nodeMap.get(key);
32            }
33        }
34
35        return null;
36    }
37}
38

1using System.Collections.Generic;

public class TreeNode {
    public int val;
    public TreeNode left;
    public TreeNode right;
    public TreeNode(int val = 0, TreeNode left = null, TreeNode right = null) {
        this.val = val;
        this.left = left;
        this.right = right;
    }
}

public class Solution {
    public TreeNode CreateBinaryTree(int[][] descriptions) {
        Dictionary<int, TreeNode> nodeMap = new Dictionary<int, TreeNode>();
        HashSet<int> children = new HashSet<int>();

        // First pass: Create all nodes
        foreach (var desc in descriptions) {
            int parent = desc[0], child = desc[1];
            if (!nodeMap.ContainsKey(parent))
                nodeMap[parent] = new TreeNode(parent);
            if (!nodeMap.ContainsKey(child))
                nodeMap[child] = new TreeNode(child);
            children.Add(child);
        }

        // Second pass: Link nodes
        foreach (var desc in descriptions) {
            int parent = desc[0], child = desc[1], isLeft = desc[2];

            if (isLeft == 1) {
                nodeMap[parent].left = nodeMap[child];
            } else {
                nodeMap[parent].right = nodeMap[child];
            }
        }

        foreach (var key in nodeMap.Keys) {
            if (!children.Contains(key)) {
                return nodeMap[key];
            }
        }

        return null;
    }
}