Binary Tree Node Structure in DSA Typescript

Mental Model

A binary tree node holds a value and links to two child nodes, one on the left and one on the right.

Analogy: Think of a family tree where each person can have up to two children, one on the left side and one on the right side.

    [Node]
    /    \
 [Left] [Right]
   null   null

Dry Run Walkthrough

Input: Create a binary tree node with value 5, left child 3, and right child 7

Goal: Build a node that connects to two child nodes correctly

Step 1: Create root node with value 5

[5] -> left: null, right: null

Why: Start with the main node that will hold the value

Step 2: Create left child node with value 3

[5] -> left: [3], right: null

Why: Add left child to hold smaller value

Step 3: Create right child node with value 7

[5] -> left: [3], right: [7]

Why: Add right child to hold larger value

Result:

[5] -> left: [3], right: [7]

Annotated Code

DSA Typescript

class TreeNode {
  value: number;
  left: TreeNode | null;
  right: TreeNode | null;

  constructor(value: number) {
    this.value = value;
    this.left = null;
    this.right = null;
  }
}

// Create root node
const root = new TreeNode(5);
// Create left child
root.left = new TreeNode(3);
// Create right child
root.right = new TreeNode(7);

// Function to print tree node and its children
function printNode(node: TreeNode | null): string {
  if (!node) return "null";
  const leftVal = node.left ? node.left.value.toString() : "null";
  const rightVal = node.right ? node.right.value.toString() : "null";
  return `[${node.value}] -> left: [${leftVal}], right: [${rightVal}]`;
}

console.log(printNode(root));

this.left = null; this.right = null;

Initialize left and right child pointers to null

root.left = new TreeNode(3);

Assign left child node with value 3

root.right = new TreeNode(7);

Assign right child node with value 7

Output

[5] -> left: [3], right: [7]

Complexity Analysis

Time: O(1) because creating a node and assigning children is a constant time operation

Space: O(1) for each node created as it stores fixed number of references and a value

vs Alternative: Compared to arrays, nodes use pointers to link children which allows dynamic tree growth without resizing

Edge Cases

Node with no children

Both left and right pointers remain null indicating leaf node

DSA Typescript

this.left = null;
this.right = null;

Node with only left child

Right pointer stays null, left points to child node

DSA Typescript

root.left = new TreeNode(3);

Node with only right child

Left pointer stays null, right points to child node

DSA Typescript

root.right = new TreeNode(7);

When to Use This Pattern

When you need to represent hierarchical data with up to two children per item, use the binary tree node structure to link nodes simply and clearly.

Common Mistakes

Mistake: Forgetting to initialize left and right pointers to null
Fix: Always set left and right to null in the constructor to avoid undefined references

Mistake: Assigning children without creating new nodes
Fix: Create new TreeNode instances before assigning to left or right pointers

Summary

It creates a node that holds a value and links to two child nodes.

Use it when building trees where each node can have up to two children.

Remember each node has two pointers that start as null and can link to child nodes.

Practice

1. What does a typical binary tree node contain in its structure?

easy

A. Only a value and a pointer to the next node

B. A value, a left child node, and a right child node

C. A value and multiple child nodes in a list

D. Only a value without any child nodes

Solution

1. Step 1: Understand binary tree node components

   A binary tree node typically stores a value and references to two children: left and right.

2. Step 2: Compare options with definition

   A value, a left child node, and a right child node correctly lists value, left child, and right child. Others describe linked list or general tree nodes.

3. Final Answer:

   A value, a left child node, and a right child node -> Option B

4. Quick Check:

   Binary tree node = value + left + right [OK]

Hint: Binary tree nodes always have two child pointers [OK]

Common Mistakes:

• Confusing binary tree node with linked list node
• Thinking nodes have multiple children like general trees
• Ignoring child pointers in node structure

2. Which of the following is the correct TypeScript syntax to define a binary tree node class?

easy

A. class Node { value: number; left: Node | undefined; right: Node | undefined; constructor(value: number) { this.value = value; this.left = null; this.right = null; } }

B. class Node { value: number; left: Node; right: Node; constructor(value: number) { this.value = value; } }

C. class Node { value: number; left: Node | null; right: Node | null; constructor(value: number) { this.value = value; this.left = null; this.right = null; } }

D. class Node { value: number; left: Node | null; right: Node | null; constructor() { this.value = 0; this.left = null; this.right = null; } }

Solution

1. Step 1: Check property types and initialization

   class Node { value: number; left: Node | null; right: Node | null; constructor(value: number) { this.value = value; this.left = null; this.right = null; } } correctly declares left and right as Node or null and initializes them to null in constructor.

2. Step 2: Verify constructor parameters and assignments

   class Node { value: number; left: Node | null; right: Node | null; constructor(value: number) { this.value = value; this.left = null; this.right = null; } } constructor takes value and sets left and right to null, matching typical binary tree node setup.

3. Final Answer:

   Correct TypeScript class with nullable children and proper constructor -> Option C

4. Quick Check:

   Nullable children + constructor with value = class Node { value: number; left: Node | null; right: Node | null; constructor(value: number) { this.value = value; this.left = null; this.right = null; } } [OK]

Hint: Child nodes must allow null to represent empty branches [OK]

Common Mistakes:

• Not initializing left and right to null
• Using undefined instead of null for children
• Missing constructor parameter for value

3. Given the following TypeScript code, what will be the output of console.log(root.left?.value)?

class Node {
  value: number;
  left: Node | null;
  right: Node | null;
  constructor(value: number) {
    this.value = value;
    this.left = null;
    this.right = null;
  }
}
const root = new Node(10);
root.left = new Node(5);
root.right = new Node(15);
console.log(root.left?.value);

medium

A. 5

B. undefined

C. null

D. 10

Solution

1. Step 1: Analyze node assignments

   root.left is assigned a new Node with value 5, so root.left is not null.

2. Step 2: Understand optional chaining and output

   Using root.left?.value safely accesses value of left node, which is 5.

3. Final Answer:

   5 -> Option A

4. Quick Check:

   root.left.value = 5 [OK]

Hint: Optional chaining returns value if node exists, else undefined [OK]

Common Mistakes:

• Confusing null and undefined outputs
• Assuming root.left is null by default
• Misreading optional chaining operator

4. Identify the error in this TypeScript binary tree node class and fix it:

class Node {
  value: number;
  left: Node;
  right: Node;
  constructor(value: number) {
    this.value = value;
    this.left = null;
    this.right = null;
  }
}

medium

A. left and right should allow null type (Node | null)

B. Constructor should not assign null to left and right

C. value should be optional in constructor

D. Class should not have a constructor

Solution

1. Step 1: Check property types vs assigned values

   left and right are typed as Node but assigned null, causing type error.

2. Step 2: Fix type declarations

   Change left and right types to Node | null to allow null assignment.

3. Final Answer:

   left and right should allow null type (Node | null) -> Option A

4. Quick Check:

   Nullable children fix type error [OK]

Hint: Child nodes must be nullable if assigned null [OK]

Common Mistakes:

• Not updating types when assigning null
• Removing constructor unnecessarily
• Making value optional without reason

5. How would you modify the binary tree node class to include a parent pointer, and what is the impact on tree traversal?

hard

A. No changes needed; parent pointer is implicit in left and right

B. Add a parent property of type number; no impact on traversal

C. Add a parent property as an array of nodes; allows multiple parents

D. Add a parent property of type Node | null; allows upward traversal from child to parent

Solution

1. Step 1: Understand parent pointer addition

   Adding a parent property of type Node | null stores reference to parent node.

2. Step 2: Impact on traversal

   This allows traversing upwards from child to parent, enabling bidirectional navigation.

3. Final Answer:

   Add a parent property of type Node | null; allows upward traversal from child to parent -> Option D

4. Quick Check:

   Parent pointer enables upward traversal [OK]

Hint: Parent pointer lets you move up the tree easily [OK]

Common Mistakes:

• Using wrong type for parent pointer
• Assuming parent pointer exists by default
• Confusing parent pointer with multiple parents