Tree Traversal Inorder Left Root Right in DSA C# - Interactive Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to visit the left subtree first in inorder traversal.

DSA C#

void InorderTraversal(Node node) {
    if (node == null) return;
    InorderTraversal(node[1]);
    Console.Write(node.Value + " -> ");
    InorderTraversal(node.Right);
}

Drag options to blanks, or click blank then click option'

A.Next

B.Right

C.Parent

D.Left

Attempts:

3 left

💡 Hint

Common Mistakes

Using node.Right instead of node.Left.

Trying to access node.Parent which is not part of traversal here.

In inorder traversal, we visit the left child first, so we use node.Left.

2fill in blank

medium

Complete the code to print the root node's value during inorder traversal.

DSA C#

void InorderTraversal(Node node) {
    if (node == null) return;
    InorderTraversal(node.Left);
    Console.Write(node[1] + " -> ");
    InorderTraversal(node.Right);
}

Drag options to blanks, or click blank then click option'

A.Left

B.Value

C.Right

D.Data

Attempts:

3 left

💡 Hint

Common Mistakes

Printing node.Left or node.Right instead of node.Value.

Using node.Data which may not exist in this class.

The root node's value is stored in node.Value, which we print in the middle of inorder traversal.

3fill in blank

hard

Fix the error in the inorder traversal call to visit the right subtree.

DSA C#

void InorderTraversal(Node node) {
    if (node == null) return;
    InorderTraversal(node.Left);
    Console.Write(node.Value + " -> ");
    InorderTraversal(node[1]);
}

Drag options to blanks, or click blank then click option'

A.Left

B.Parent

C.Right

D.Next

Attempts:

3 left

💡 Hint

Common Mistakes

Calling InorderTraversal(node.Left) again instead of node.Right.

Using node.Parent which is not part of traversal here.

In inorder traversal, after visiting the root, we visit the right subtree using node.Right.

4fill in blank

hard

Fill both blanks to complete the inorder traversal method with correct recursive calls.

DSA C#

void InorderTraversal(Node node) {
    if (node == null) return;
    InorderTraversal(node[1]);
    Console.Write(node.Value + " -> ");
    InorderTraversal(node[2]);
}

Drag options to blanks, or click blank then click option'

A.Left

B.Right

C.Parent

D.Next

Attempts:

3 left

💡 Hint

Common Mistakes

Swapping left and right calls.

Using node.Parent or node.Next which are not part of traversal.

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

5fill in blank

hard

Fill all three blanks to create a dictionary that maps node values to their inorder traversal index.

DSA C#

Dictionary<int, int> inorderIndex = new Dictionary<int, int>();
int index = 0;
void InorderTraversalIndex(Node node) {
    if (node == null) return;
    InorderTraversalIndex(node[1]);
    inorderIndex[node[2]] = index[3];
    InorderTraversalIndex(node.Right);
}

Drag options to blanks, or click blank then click option'

A.Left

B.Value

C++

D--

Attempts:

3 left

💡 Hint

Common Mistakes

Using node.Right instead of node.Left for first call.

Using -- instead of ++ for index.

Using node.Data instead of node.Value.

We visit left subtree first, then assign current node's value to index and increment index.

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 means visiting the left subtree first, then the root node, and finally the right subtree.

2. Step 2: Apply the order to the tree nodes

   This order ensures nodes are visited in ascending order for binary search trees.

3. Final Answer:

   Left subtree, Root, Right subtree -> Option A

4. Quick Check:

   Inorder = Left, Root, Right [OK]

Hint: Remember: Inorder = Left, Root, Right [OK]

Common Mistakes:

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

2. Which of the following C# method signatures correctly represents an inorder traversal method for a binary tree node class named Node?

easy

A. void InorderTraversal(Node root)

B. int InorderTraversal(Node root)

C. Node InorderTraversal()

D. bool InorderTraversal(Node root)

Solution

1. Step 1: Identify the purpose of the method

   An inorder traversal method typically visits nodes and prints or processes them without returning a value, so it should be void.

2. Step 2: Check method signature options

   void InorderTraversal(Node root) uses void return type and accepts a Node parameter, which is correct for traversal.

3. Final Answer:

   void InorderTraversal(Node root) -> Option A

4. Quick Check:

   Traversal methods usually return void [OK]

Hint: Traversal methods usually return void [OK]

Common Mistakes:

• Using return types like int or bool unnecessarily
• Missing the root parameter
• Returning Node instead of void

3. Given the following binary tree:

    2
   / \
  1   3

What is the output of the inorder traversal method that prints node values?

medium

A. 1 3 2

B. 2 1 3

C. 3 2 1

D. 1 2 3

Solution

1. Step 1: Apply inorder traversal on the tree

   Visit left subtree (1), then root (2), then right subtree (3).

2. Step 2: Write the visited nodes in order

   The nodes are visited in order: 1, 2, 3.

3. Final Answer:

   1 2 3 -> Option D

4. Quick Check:

   Inorder traversal output = 1 2 3 [OK]

Hint: Inorder prints nodes in ascending order for BST [OK]

Common Mistakes:

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

4. Consider this C# inorder traversal method:

void InorderTraversal(Node root) {
    if (root == null) return;
    InorderTraversal(root.Right);
    Console.Write(root.Value + " ");
    InorderTraversal(root.Left);
}

What is the error in this code?

medium

A. It causes infinite recursion

B. It misses the base case for null root

C. It visits right subtree before left subtree, reversing inorder order

D. It does not print the root value

Solution

1. Step 1: Analyze the traversal order in the code

   The code visits root.Right first, then root, then root.Left, which is reverse of inorder.

2. Step 2: Identify the correct inorder order

   Inorder should visit left subtree first, then root, then right subtree.

3. Final Answer:

   It visits right subtree before left subtree, reversing inorder order -> Option C

4. Quick Check:

   Inorder = Left, Root, Right [OK]

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

Common Mistakes:

• Swapping left and right subtree calls
• Forgetting to check for null root
• Not printing root value

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

hard

A. void Inorder(Node root, List<int> result) {
if (root == null) return;
result.Add(root.Value);
Inorder(root.Left, result);
Inorder(root.Right, result);
}

B. void Inorder(Node root, List<int> result) {
if (root == null) return;
Inorder(root.Left, result);
result.Add(root.Value);
Inorder(root.Right, result);
}

C. void Inorder(Node root, List<int> result) {
if (root == null) return;
Inorder(root.Right, result);
result.Add(root.Value);
Inorder(root.Left, result);
}

D. void Inorder(Node root, List<int> result) {
if (root == null) return;
Inorder(root.Left, result);
Inorder(root.Right, result);
result.Add(root.Value);
}

Solution

1. Step 1: Recall inorder traversal order

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

2. Step 2: Check which code matches this order

   void Inorder(Node root, List<int> result) { if (root == null) return; Inorder(root.Left, result); result.Add(root.Value); Inorder(root.Right, result); } visits left subtree, adds root value, then visits right subtree, correctly collecting values in order.

3. Final Answer:

   void Inorder(Node root, List<int> result) { if (root == null) return; Inorder(root.Left, result); result.Add(root.Value); Inorder(root.Right, result); } -> Option B

4. Quick Check:

   Left, Root, Right order with result.Add(root.Value) in middle [OK]

Hint: Add root value between left and right recursive calls [OK]

Common Mistakes:

• Adding root value before left subtree
• Adding root value after right subtree
• Swapping left and right subtree calls