Build a Binary Tree

Create a fixed seven-node binary tree and render its shape.

Algorithm

The canonical tree is 4(2(1,3),6(5,7)), so this Java DSA implementation can be compared directly with the rest of the DSA track.

Basic Implementation

Basic.java

import java.util.*;

public class Basic {
    static class Node {
        int value;
        Node left;
        Node right;
        Node(int value) { this.value = value; }
        Node(int value, Node left, Node right) { this.value = value; this.left = left; this.right = right; }
    }
    static String render(Node node) {
        if (node == null) return "_";
        if (node.left == null && node.right == null) return Integer.toString(node.value);
        return node.value + "(" + render(node.left) + "," + render(node.right) + ")";
    }
    static Node sampleTree() {
        return new Node(4, new Node(2, new Node(1), new Node(3)), new Node(6, new Node(5), new Node(7)));
    }
    public static void main(String[] args) { System.out.println(render(sampleTree())); }
}

Complexity

Time: O(n)
Space: O(n)

Implementation notes

Java represents each tree node as a Node object with primitive int value plus Node left and Node right reference fields. The one-argument constructor leaves child references at their default null value.
sampleTree() wires the tree with nested constructor calls: new Node(4, new Node(2, new Node(1), new Node(3)), new Node(6, new Node(5), new Node(7))). Java evaluates those arguments left to right, matching the replay order that creates leaves before their parents.
The two-argument-child constructor stores existing node object references into left and right; no queue, list, or builder structure is involved.
render checks node == null for missing children, prints leaf values directly, and recursively formats internal nodes as value(left,right). The allocated Node objects and render-time strings are normal JVM heap objects managed by GC after printing 4(2(1,3),6(5,7)).

node links A node stores one value plus references to its left and right children.