Tree Traversal Inorder Left Root Right in DSA Typescript - Practice Problems & Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

What is the inorder traversal output of this binary tree?

Given the binary tree below, what is the output of inorder traversal (Left, Root, Right)?

DSA Typescript

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

const root = new Node(2, new Node(1), new Node(3));

function inorderTraversal(root: Node | null): number[] {
  if (!root) return [];
  return [...inorderTraversal(root.left), root.val, ...inorderTraversal(root.right)];
}

console.log(inorderTraversal(root));

A [1, 2, 3]

B [1, 3, 2]

C [3, 2, 1]

D [2, 1, 3]

💡 Hint

Remember inorder traversal visits left child first, then root, then right child.

Inorder traversal visits nodes in the order: left subtree, root, right subtree.

For the tree with root 2, left child 1, and right child 3, the order is 1, 2, 3.

❓ Predict Output

intermediate

What is the inorder traversal output of this unbalanced tree?

Given the binary tree below, what is the output of inorder traversal (Left, Root, Right)?

DSA Typescript

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

const root = new Node(4, new Node(2, new Node(1), new Node(3)), new Node(5));

function inorderTraversal(root: Node | null): number[] {
  if (!root) return [];
  return [...inorderTraversal(root.left), root.val, ...inorderTraversal(root.right)];
}

console.log(inorderTraversal(root));

A [1, 2, 3, 4, 5]

B [5, 4, 3, 2, 1]

C [4, 2, 1, 3, 5]

D [2, 1, 3, 4, 5]

💡 Hint

Traverse left subtree fully before root, then right subtree.

Inorder traversal visits left subtree nodes first, then root, then right subtree nodes.

For this tree, the order is 1, 2, 3, 4, 5.

🔧 Debug

advanced

Why does this inorder traversal code cause a runtime error?

Find the cause of the runtime error in this inorder traversal function.

DSA Typescript

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

function inorderTraversal(root: Node | null): number[] {
  if (root === null) return [];
  const left = inorderTraversal(root.left);
  const right = inorderTraversal(root.right);
  return left.concat([root.val]).concat(right);
}

const root = new Node(1);
console.log(inorderTraversal(root));

A No error, outputs [1]

B SyntaxError due to missing semicolon

C Stack overflow due to infinite recursion

D TypeError because concat expects an array but root.val is a number

💡 Hint

Check the types passed to concat method.

The concat method expects an array argument, but root.val is a number.

This causes a TypeError at runtime.

❓ Predict Output

advanced

What is the inorder traversal output of this tree with null children?

Given the binary tree below, what is the output of inorder traversal (Left, Root, Right)?

DSA Typescript

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

const root = new Node(10, null, new Node(20, new Node(15), null));

function inorderTraversal(root: Node | null): number[] {
  if (!root) return [];
  return [...inorderTraversal(root.left), root.val, ...inorderTraversal(root.right)];
}

console.log(inorderTraversal(root));

A [20, 15, 10]

B [10, 15, 20]

C [15, 20, 10]

D [10, 20, 15]

💡 Hint

Remember to visit left subtree before root, even if left is null.

Inorder traversal visits left subtree, root, then right subtree.

Here, left of root is null, so visit root 10, then traverse right subtree which visits 15 then 20.

🧠 Conceptual

expert

How many nodes are visited before the root in inorder traversal of a complete binary tree of height 3?

Consider a complete binary tree of height 3 (levels 0 to 3). How many nodes are visited before the root node during an inorder traversal?

A 4

B 6

C 7

D 3

💡 Hint

Count all nodes in the left subtree of the root.

In inorder traversal, all nodes in the left subtree are visited before the root.

A complete binary tree of height 3 has 7 nodes in the left subtree (levels 1 and 2 fully filled).

Practice

1. What is the order of nodes visited in an inorder traversal of a binary tree?

easy

A. Left subtree, Root, Right subtree

B. Root, Left subtree, Right subtree

C. Right subtree, Root, Left subtree

D. Root, Right subtree, Left subtree

Solution

1. Step 1: Understand inorder traversal definition

   Inorder traversal visits nodes in the order: left subtree first, then the root node, and finally the right subtree.

2. Step 2: Match the traversal order to options

   Left subtree, Root, Right subtree correctly states the order as Left subtree, Root, Right subtree.

3. Final Answer:

   Left subtree, Root, Right subtree -> Option A

4. Quick Check:

   Inorder = Left, Root, Right [OK]

Hint: Inorder always visits left child before root [OK]

Common Mistakes:

• Confusing inorder with preorder or postorder
• Visiting root before left subtree
• Visiting right subtree before root

2. Which of the following TypeScript function signatures correctly represents an inorder traversal function for a binary tree node?

easy

A. function inorder(node: TreeNode): number[]

B. function inorder(node: TreeNode | null): void

C. function inorder(): void

D. function inorder(node: TreeNode | null): number

Solution

1. Step 1: Analyze function parameters and return type

   An inorder traversal function typically takes a node or null as input and performs traversal, often printing or processing nodes without returning a value.

2. Step 2: Check options for correct signature

   function inorder(node: TreeNode | null): void accepts a node or null and returns void, which fits traversal that prints or processes nodes.

3. Final Answer:

   function inorder(node: TreeNode | null): void -> Option B

4. Quick Check:

   Traversal function takes node or null, returns void [OK]

Hint: Traversal functions usually take node or null, return void [OK]

Common Mistakes:

• Omitting null in parameter type
• Returning incorrect types like number or array
• Missing parameter in function signature

3. Given the following binary tree:

    2
   / \
  1   3

What is the output of inorder traversal printing node values?

medium

A. [2, 1, 3]

B. [3, 2, 1]

C. [1, 3, 2]

D. [1, 2, 3]

Solution

1. Step 1: Visualize the tree and inorder traversal

   Inorder visits left subtree, root, then right subtree. For root 2, left child is 1, right child is 3.

2. Step 2: List nodes in inorder

   Visit left: 1, then root: 2, then right: 3, so output is [1, 2, 3].

3. Final Answer:

   [1, 2, 3] -> Option D

4. Quick Check:

   Inorder of 2-node tree = [1, 2, 3] [OK]

Hint: Inorder prints nodes sorted for BST [OK]

Common Mistakes:

• Printing root before left subtree
• Swapping left and right subtree order
• Confusing preorder or postorder output

4. Consider this TypeScript inorder traversal function:

function inorder(node: TreeNode | null): void {
  if (node === null) return;
  inorder(node.right);
  console.log(node.val);
  inorder(node.left);
}

What is the main problem with this code?

medium

A. It prints node values twice

B. It does not handle null nodes properly

C. It visits right subtree before left, so traversal order is incorrect

D. It causes infinite recursion

Solution

1. Step 1: Analyze traversal order in code

   The function calls inorder on right subtree first, then prints root, then calls inorder on left subtree.

2. Step 2: Compare with correct inorder order

   Correct inorder is left subtree, root, right subtree. This code reverses left and right, so order is wrong.

3. Final Answer:

   It visits right subtree before left, so traversal order is incorrect -> Option C

4. Quick Check:

   Inorder must visit left before right [OK]

Hint: Inorder must call left subtree before right [OK]

Common Mistakes:

• Swapping left and right subtree calls
• Forgetting base case for null
• Printing before recursive calls

5. You have a binary tree where each node contains a number. You want to collect all node values in an array using inorder traversal. Which TypeScript code snippet correctly implements this?

hard

A. function inorder(node: TreeNode | null, arr: number[]): void {
if (!node) return;
inorder(node.left, arr);
arr.push(node.val);
inorder(node.right, arr);
}

B. function inorder(node: TreeNode | null, arr: number[]): void {
if (!node) return;
arr.push(node.val);
inorder(node.left, arr);
inorder(node.right, arr);
}

C. function inorder(node: TreeNode | null, arr: number[]): void {
if (!node) return;
inorder(node.right, arr);
arr.push(node.val);
inorder(node.left, arr);
}

D. function inorder(node: TreeNode | null): number[] {
if (!node) return [];
return [node.val].concat(inorder(node.left)).concat(inorder(node.right));
}

Solution

1. Step 1: Understand inorder traversal with array accumulation

   We must visit left subtree, then root (push value), then right subtree, passing the same array to collect values.

2. Step 2: Check each option for correct order and array usage

   function inorder(node: TreeNode | null, arr: number[]): void { if (!node) return; inorder(node.left, arr); arr.push(node.val); inorder(node.right, arr); } correctly visits left, pushes root value, then visits right, using the same array.

3. Final Answer:

   function inorder(node: TreeNode | null, arr: number[]): void { if (!node) return; inorder(node.left, arr); arr.push(node.val); inorder(node.right, arr); } -> Option A

4. Quick Check:

   Left, root, right with shared array [OK]

Hint: Push node value after left subtree call [OK]

Common Mistakes:

• Pushing before left subtree traversal
• Swapping left and right subtree calls
• Returning new arrays instead of using passed array