1class TreeNode {
2    constructor(val, left = null, right = null) {
3        this.val = val;
4        this.left = left;
5        this.right = right;
6    }
7}
8
9function createBinaryTree(descriptions) {
10    const nodeMap = new Map();
11    const children = new Set();
12
13    for (const [parent, child, isLeft] of descriptions) {
14        if (!nodeMap.has(parent)) {
15            nodeMap.set(parent, new TreeNode(parent));
16        }
17        if (!nodeMap.has(child)) {
18            nodeMap.set(child, new TreeNode(child));
19        }
20
21        if (isLeft === 1) {
22            nodeMap.get(parent).left = nodeMap.get(child);
23        } else {
24            nodeMap.get(parent).right = nodeMap.get(child);
25        }
26        children.add(child);
27    }
28
29    for (const [key, node] of nodeMap) {
30        if (!children.has(key)) {
31            return node;
32        }
33    }
34    return null;
35}
36

#include <unordered_set>
#include <vector>
using namespace std;

class TreeNode {
public:
    int val;
    TreeNode* left;
    TreeNode* right;
    TreeNode(int value) : val(value), left(nullptr), right(nullptr) {}
};

class Solution {
public:
    TreeNode* createBinaryTree(vector<vector<int>>& descriptions) {
        unordered_map<int, TreeNode*> nodes;
        unordered_set<int> children;

        // First pass to create all tree nodes
        for (const auto& desc : descriptions) {
            if (nodes.find(desc[0]) == nodes.end())
                nodes[desc[0]] = new TreeNode(desc[0]);
            if (nodes.find(desc[1]) == nodes.end())
                nodes[desc[1]] = new TreeNode(desc[1]);

            children.insert(desc[1]);
        }

        // Second pass to link tree nodes
        for (const auto& desc : descriptions) {
            int parent = desc[0], child = desc[1], isLeft = desc[2];

            if (isLeft) {
                nodes[parent]->left = nodes[child];
            } else {
                nodes[parent]->right = nodes[child];
            }
        }

        for (const auto& [key, node] : nodes) {
            if (children.find(key) == children.end()) {
                return node;
            }
        }

        return nullptr;
    }
};