Create a Binary Tree Manually in DSA Javascript - Practice Problems & Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

What is the output after inserting nodes manually?

Consider the following JavaScript code that creates a binary tree by manually linking nodes. What will be the printed output of the tree in in-order traversal (left, root, right)?

DSA Javascript

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);
root.left.left = new Node(3);
root.left.right = new Node(7);
root.right.right = new Node(18);

function inorder(node) {
  if (!node) return [];
  return [...inorder(node.left), node.value, ...inorder(node.right)];
}

console.log(inorder(root).join(' -> ') + ' -> null');

A 3 -> 7 -> 5 -> 10 -> 18 -> 15 -> null

B 10 -> 5 -> 3 -> 7 -> 15 -> 18 -> null

C 3 -> 5 -> 7 -> 10 -> 15 -> 18 -> null

D 5 -> 3 -> 7 -> 10 -> 15 -> 18 -> null

💡 Hint

In-order traversal visits left child, then node, then right child.

In-order traversal visits nodes in ascending order for a binary search tree. The nodes are visited as 3, 5, 7, 10, 15, 18.

🧠 Conceptual

intermediate

How many nodes are in this manually created binary tree?

Given the following manual binary tree creation code, how many nodes does the tree contain?

DSA Javascript

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

const root = new Node(1);
root.left = new Node(2);
root.right = new Node(3);
root.left.left = new Node(4);
root.left.right = new Node(5);
root.right.left = new Node(6);
root.right.right = new Node(7);

A 7

B 6

C 5

D 8

💡 Hint

Count each new Node created and linked.

The tree has nodes with values 1, 2, 3, 4, 5, 6, and 7, totaling 7 nodes.

🔧 Debug

advanced

What error does this manual binary tree creation code produce?

Examine the code below that attempts to create a binary tree manually. What error will it raise when run?

DSA Javascript

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);
root.left.left = new Node(3);
root.left.right = new Node(7);
root.right.right.left = new Node(18); // Problematic line

A ReferenceError: root.right.right is not defined

B TypeError: Cannot set property 'left' of null

C SyntaxError: Unexpected token '.'

D No error, runs successfully

💡 Hint

Check if all intermediate nodes exist before assigning children.

root.right.right is null by default, so trying to assign left property on null causes a TypeError.

❓ Predict Output

advanced

What is the output of this pre-order traversal of a manually created binary tree?

Given the following binary tree created manually, what is the output of the pre-order traversal (root, left, right)?

DSA Javascript

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

const root = new Node(8);
root.left = new Node(3);
root.right = new Node(10);
root.left.left = new Node(1);
root.left.right = new Node(6);
root.left.right.left = new Node(4);
root.left.right.right = new Node(7);
root.right.right = new Node(14);
root.right.right.left = new Node(13);

function preorder(node) {
  if (!node) return [];
  return [node.value, ...preorder(node.left), ...preorder(node.right)];
}

console.log(preorder(root).join(' -> ') + ' -> null');

A 8 -> 3 -> 1 -> 6 -> 4 -> 7 -> 10 -> 14 -> 13 -> null

B 1 -> 3 -> 4 -> 6 -> 7 -> 8 -> 10 -> 13 -> 14 -> null

C 3 -> 1 -> 6 -> 4 -> 7 -> 8 -> 10 -> 14 -> 13 -> null

D 8 -> 3 -> 6 -> 1 -> 7 -> 4 -> 10 -> 14 -> 13 -> null

💡 Hint

Pre-order visits root first, then left subtree, then right subtree.

Pre-order traversal visits nodes in order: 8 (root), 3 (left), 1 (left-left), 6 (left-right), 4 (left-right-left), 7 (left-right-right), 10 (right), 14 (right-right), 13 (right-right-left).

🧠 Conceptual

expert

What is the height of this manually created binary tree?

Consider the binary tree created manually below. What is the height of this tree? Height is the number of edges on the longest path from root to a leaf.

DSA Javascript

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 = new Node(5);
root.left.left.left = new Node(2);
root.right.right = new Node(40);
root.right.right.right = new Node(50);
root.right.right.right.right = new Node(60);

A 5

B 3

C 6

D 4

💡 Hint

Count edges from root to the deepest leaf node.

The longest path is from root (20) to 60: edges are 20->30, 30->40, 40->50, 50->60, total 4 edges, so height is 4.

Practice

1. What is the main purpose of creating a binary tree manually in JavaScript?

easy

A. To convert a string into an array

B. To automatically sort numbers in an array

C. To create a list of numbers without any hierarchy

D. To build a tree structure by linking nodes with left and right children

Solution

1. Step 1: Understand what a binary tree is

   A binary tree is a structure where each node has up to two children: left and right.

2. Step 2: Purpose of manual creation

   Manually creating a binary tree means linking nodes by setting their left and right child references.

3. Final Answer:

   To build a tree structure by linking nodes with left and right children -> Option D

4. Quick Check:

   Binary tree = linked nodes with left/right children [OK]

Hint: Binary tree nodes link left and right children manually [OK]

Common Mistakes:

• Thinking binary tree sorts data automatically
• Confusing binary tree with arrays or lists
• Assuming binary tree nodes have more than two children

2. Which of the following is the correct way to create a node object for a binary tree in JavaScript?

easy

A. const node = [5, null, null];

B. const node = (5, null, null);

C. const node = { value: 5, left: null, right: null };

D. const node = 5, left = null, right = null;

Solution

1. Step 1: Understand JavaScript object syntax

   Objects use curly braces with key-value pairs, e.g., { key: value }.

2. Step 2: Check each option

   const node = { value: 5, left: null, right: null }; correctly uses an object with keys value, left, right. Others use array, parentheses, or invalid syntax.

3. Final Answer:

   const node = { value: 5, left: null, right: null }; -> Option C

4. Quick Check:

   Node as object with keys = const node = { value: 5, left: null, right: null }; [OK]

Hint: Use curly braces for node objects with keys [OK]

Common Mistakes:

• Using arrays instead of objects for nodes
• Using parentheses instead of braces
• Trying to declare multiple variables without braces

3. What will be the output of the following code that manually creates a binary tree and prints the root node's left child's value?

const root = { value: 10, left: { value: 5, left: null, right: null }, right: { value: 15, left: null, right: null } };
console.log(root.left.value);

medium

A. 5

B. 15

C. 10

D. undefined

Solution

1. Step 1: Understand the tree structure

   Root node has value 10, left child with value 5, right child with value 15.

2. Step 2: Access root.left.value

   root.left points to node with value 5, so root.left.value is 5.

3. Final Answer:

   5 -> Option A

4. Quick Check:

   root.left.value = 5 [OK]

Hint: Access left child value with root.left.value [OK]

Common Mistakes:

• Confusing root value with left child value
• Accessing root.right.value instead
• Expecting undefined if not careful with null checks

4. Identify the error in the following code that tries to create a binary tree node manually:

const node = { value: 7, left: null, right: null };
node.left.value = 3;

medium

A. Cannot assign value to left because left is null

B. Syntax error in object declaration

C. Missing semicolon after node declaration

D. No error, code runs fine

Solution

1. Step 1: Analyze node.left value

   node.left is set to null, so it has no properties.

2. Step 2: Assigning to node.left.value

   Trying to assign node.left.value = 3 causes error because node.left is null, cannot set property on null.

3. Final Answer:

   Cannot assign value to left because left is null -> Option A

4. Quick Check:

   Assigning property on null causes error [OK]

Hint: Check if child node exists before assigning properties [OK]

Common Mistakes:

• Ignoring that null has no properties
• Assuming automatic node creation on assignment
• Thinking missing semicolon causes error here

5. You want to manually create a binary tree with root value 20, left child 10, and right child 30. Which code correctly creates this tree and prints the right child's value?

hard

A. const root = { value: 20, left: 10, right: 30 };
console.log(root.right);

B. const root = { value: 20, left: { value: 10, left: null, right: null }, right: { value: 30, left: null, right: null } };
console.log(root.right.value);

C. const root = { value: 20, left: { 10 }, right: { 30 } };
console.log(root.right.value);

D. const root = { value: 20, left: null, right: null };
root.left = { value: 10, left: null, right: null };
root.right = { value: 30, left: null, right: null };
console.log(root.right.value);

Solution

1. Step 1: Check tree node structure

   Each child must be an object with value, left, right keys or null.

2. Step 2: Evaluate each option

   const root = { value: 20, left: { value: 10, left: null, right: null }, right: { value: 30, left: null, right: null } }; console.log(root.right.value); correctly creates left and right child nodes as objects with proper keys. const root = { value: 20, left: 10, right: 30 }; console.log(root.right); uses numbers directly, not objects. const root = { value: 20, left: { 10 }, right: { 30 } }; console.log(root.right.value); uses invalid object syntax. const root = { value: 20, left: null, right: null }; root.left.value = 10; root.right.value = 30; console.log(root.right.value); tries to assign properties to null children causing error.

3. Final Answer:

   const root = { value: 20, left: { value: 10, left: null, right: null }, right: { value: 30, left: null, right: null } }; console.log(root.right.value); -> Option B

4. Quick Check:

   Proper node objects with children = const root = { value: 20, left: { value: 10, left: null, right: null }, right: { value: 30, left: null, right: null } }; console.log(root.right.value); [OK]

Hint: Children must be objects with value, left, right keys [OK]

Common Mistakes:

• Assigning numbers directly as children
• Using invalid object syntax for children
• Assigning properties to null children