Binary Tree Node Structure in DSA Javascript - Build from Scratch

Binary Tree Node Structure

📖 Scenario: Imagine you are building a simple family tree app. Each person can have up to two children. To represent this, you will create a binary tree node structure in JavaScript.

🎯 Goal: You will create a binary tree node structure with a value and two child nodes (left and right). Then, you will create a sample node and print its value.

📋 What You'll Learn

Create a class called TreeNode with a constructor that takes a value parameter

The constructor should set this.value to the given value

The constructor should initialize this.left and this.right to null

Create a variable called root that is an instance of TreeNode with value 10

Print the value of root using console.log

💡 Why This Matters

🌍 Real World

Binary trees are used in many applications like organizing data, searching quickly, and representing hierarchical information such as family trees or file systems.

💼 Career

Understanding how to create and manipulate tree structures is important for software development roles that involve data organization, algorithms, and system design.

1

Create the TreeNode class

Create a class called TreeNode with a constructor that takes a parameter value. Inside the constructor, set this.value to value, and set this.left and this.right to null.

DSA Javascript

# Your code here

Hint

Use class keyword and define a constructor method. Initialize this.value, this.left, and this.right.

2

Create the root node

Create a variable called root and assign it a new instance of TreeNode with the value 10.

DSA Javascript

class TreeNode {
    constructor(value) {
        this.value = value;
        this.left = null;
        this.right = null;
    }
}

// Create root node here
# Your code here

Hint

Use const root = new TreeNode(10); to create the root node.

3

Add left and right children

Add two children to the root node. Set root.left to a new TreeNode with value 5 and root.right to a new TreeNode with value 15.

DSA Javascript

class TreeNode {
    constructor(value) {
        this.value = value;
        this.left = null;
        this.right = null;
    }
}

const root = new TreeNode(10);

// Add left and right children to root
# Your code here

Hint

Use root.left = new TreeNode(5); and root.right = new TreeNode(15); to add children.

4

Print the root node value

Print the value of the root node using console.log(root.value).

DSA Javascript

class TreeNode {
    constructor(value) {
        this.value = value;
        this.left = null;
        this.right = null;
    }
}

const root = new TreeNode(10);
root.left = new TreeNode(5);
root.right = new TreeNode(15);

// Print root value
# Your code here

Hint

Use console.log(root.value); to print the root node's value.

Practice

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

easy

A. A value and multiple child nodes in a list

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

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

D. Only a value without any child references

Solution

1. Step 1: Understand binary tree node components

   A binary tree node stores a value and has exactly two child references: left and right.

2. Step 2: Compare options with binary tree 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 left and right 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 JavaScript syntax to define a binary tree node class?

easy

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

B. function Node(value) { this.value = value; this.next = null; }

C. class Node { constructor(value) { this.value = value; this.children = []; } }

D. var Node = (value) => { this.value = value; this.left = null; this.right = null; }

Solution

1. Step 1: Identify correct class syntax for binary tree node

   class Node { constructor(value) { this.value = value; this.left = null; this.right = null; } } uses ES6 class with constructor setting value, left, and right to null.

2. Step 2: Check other options for errors

   function Node(value) { this.value = value; this.next = null; } uses next pointer (linked list), C uses children array (general tree), D uses arrow function incorrectly for constructor.

3. Final Answer:

   class Node { constructor(value) { this.value = value; this.left = null; this.right = null; } } -> Option A

4. Quick Check:

   Class with value, left, right = class Node { constructor(value) { this.value = value; this.left = null; this.right = null; } } [OK]

Hint: Use ES6 class with left and right set to null [OK]

Common Mistakes:

• Using 'next' instead of 'left' and 'right'
• Using arrow function as constructor
• Using children array instead of left/right

3. What will be the output of the following code?

class Node {
  constructor(value) {
    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 + ' -> ' + root.value + ' -> ' + root.right.value);

medium

A. "5 -> 10 -> 15"

B. "10 -> 5 -> 15"

C. "null -> 10 -> null"

D. "15 -> 10 -> 5"

Solution

1. Step 1: Trace node creation and assignments

   Root node value is 10, left child is 5, right child is 15.

2. Step 2: Evaluate console.log output

   Output concatenates left.value (5), root.value (10), right.value (15) with arrows.

3. Final Answer:

   "5 -> 10 -> 15" -> Option A

4. Quick Check:

   Left 5, root 10, right 15 = "5 -> 10 -> 15" [OK]

Hint: Print left, root, right values in order [OK]

Common Mistakes:

• Mixing order of values in output
• Confusing left and right child values
• Forgetting to access .value property

4. Identify the error in the following binary tree node code snippet:

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

const root = new Node(20);
root.left = new Node(10);
root.right = new Node(30);
root.left.left = 15;
console.log(root.left.left.value);

medium

A. Missing constructor in Node class

B. Using console.log incorrectly

C. Assigning a number directly instead of a Node object to left.left

D. root.right is not assigned properly

Solution

1. Step 1: Analyze assignment to root.left.left

   root.left.left is assigned 15 (a number), not a Node instance.

2. Step 2: Understand why console.log fails

   Accessing .value on a number (15) causes error because 15 has no .value property.

3. Final Answer:

   Assigning a number directly instead of a Node object to left.left -> Option C

4. Quick Check:

   Child nodes must be Node objects, not raw values [OK]

Hint: Child nodes must be Node instances, not raw values [OK]

Common Mistakes:

• Assigning raw values instead of Node objects
• Ignoring error from accessing .value on number
• Assuming constructor is missing

5. Given the following binary tree node class, how would you write a function to count the total number of nodes in the tree starting from the root?

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

Choose the correct function implementation.

hard

A. function countNodes(node) { if (node === null) return null; return 1 + countNodes(node.left) + countNodes(node.right); }

B. function countNodes(node) { if (!node) return 1; return countNodes(node.left) + countNodes(node.right); }

C. function countNodes(node) { return node.value + countNodes(node.left) + countNodes(node.right); }

D. function countNodes(node) { if (!node) return 0; return 1 + countNodes(node.left) + countNodes(node.right); }

Solution

1. Step 1: Understand base case for recursion

   If node is null, count is zero because no node exists there.

2. Step 2: Sum current node plus counts of left and right subtrees

   Return 1 (current node) plus recursive counts of left and right children.

3. Step 3: Check options for correct base case and sum

   function countNodes(node) { if (!node) return 0; return 1 + countNodes(node.left) + countNodes(node.right); } correctly returns 0 for null and sums 1 + left + right counts.

4. Final Answer:

   function countNodes(node) { if (!node) return 0; return 1 + countNodes(node.left) + countNodes(node.right); } -> Option D

5. Quick Check:

   Count nodes = 1 + left count + right count [OK]

Hint: Return 0 for null, else 1 + left + right counts [OK]

Common Mistakes:

• Returning 1 for null node instead of 0
• Adding node.value instead of count 1
• Returning null instead of 0 in base case