Tree Traversal Preorder Root Left Right in DSA C# - Practice Problems & Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

What is the output of this preorder traversal?

Given the binary tree below, what is the preorder traversal output?

Tree structure:
1
/ \
2 3
/ / \
4 5 6

DSA C#

class Node {
    public int val;
    public Node left, right;
    public Node(int v) { val = v; left = right = null; }
}

void Preorder(Node root) {
    if (root == null) return;
    Console.Write(root.val + " ");
    Preorder(root.left);
    Preorder(root.right);
}

// Tree creation
Node root = new Node(1);
root.left = new Node(2);
root.right = new Node(3);
root.left.left = new Node(4);
root.right.left = new Node(5);
root.right.right = new Node(6);

Preorder(root);

A 1 3 5 6 2 4

B 1 2 4 3 5 6

C 4 2 1 5 3 6

D 2 4 1 3 5 6

💡 Hint

Remember preorder visits root first, then left subtree, then right subtree.

Preorder traversal visits nodes in Root-Left-Right order. Starting at 1, then left subtree (2, then 4), then right subtree (3, then 5 and 6).

🧠 Conceptual

intermediate

Which node is visited second in preorder traversal?

In preorder traversal (Root, Left, Right), which node is visited second in the tree below?

Tree:
10
/ \
20 30
/
40

A 20

B 10

C 30

D 40

💡 Hint

Preorder visits root first, then left child.

Preorder visits root (10) first, then left child (20) second.

🔧 Debug

advanced

Why does this preorder traversal code cause a stack overflow?

Consider this preorder traversal code snippet. Why does it cause a stack overflow when run on a large tree?

Code:
void Preorder(Node root) { if (root == null) return; Console.Write(root.val + " "); Preorder(root.left); Preorder(root.right); }

A Because it visits right child before left child causing infinite loops.

B Because it modifies the tree nodes during traversal causing corruption.

C Because it does not check for null nodes before visiting them.

D Because it uses recursion without tail call optimization, causing deep call stacks on large trees.

💡 Hint

Think about how recursion uses the call stack.

The recursive calls add to the call stack for each node. For very deep trees, this can exceed the stack size and cause overflow.

❓ Predict Output

advanced

What is the preorder traversal output of this unbalanced tree?

Given the tree below, what is the preorder traversal output?

Tree structure:
7
\
8
\
9
/
10

DSA C#

class Node {
    public int val;
    public Node left, right;
    public Node(int v) { val = v; left = right = null; }
}

void Preorder(Node root) {
    if (root == null) return;
    Console.Write(root.val + " ");
    Preorder(root.left);
    Preorder(root.right);
}

Node root = new Node(7);
root.right = new Node(8);
root.right.right = new Node(9);
root.right.right.left = new Node(10);

Preorder(root);

A 7 9 8 10

B 7 8 10 9

C 7 8 9 10

D 10 9 8 7

💡 Hint

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

Start at 7, no left child, go right to 8, then right to 9, then left to 10.

🚀 Application

expert

How many nodes are visited in preorder traversal of this tree?

Given the tree below, how many nodes will be visited during preorder traversal?

Tree structure:
15
/ \
10 20
/ / \
8 17 25
\
19

A 7

B 6

C 8

D 5

💡 Hint

Count all nodes in the tree.

Nodes are 15,10,8,20,17,19,25 totaling 7 nodes.

Practice

1. What is the order of nodes visited in a preorder tree traversal?

easy

A. Left, Root, Right

B. Right, Left, Root

C. Left, Right, Root

D. Root, Left, Right

Solution

1. Step 1: Understand preorder traversal definition

   Preorder traversal visits the root node first, then recursively visits the left subtree, followed by the right subtree.

2. Step 2: Confirm the visiting order

   The visiting order is Root, then Left subtree, then Right subtree.

3. Final Answer:

   Root, Left, Right -> Option D

4. Quick Check:

   Preorder = Root, Left, Right [OK]

Hint: Remember: Preorder starts with the root node first [OK]

Common Mistakes:

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

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

easy

A. void PreorderTraversal(Node root)

B. int PreorderTraversal(Node root)

C. Node PreorderTraversal()

D. void PreorderTraversal()

Solution

1. Step 1: Identify typical preorder traversal method signature

   Preorder traversal usually processes nodes and does not return a value, so it returns void and takes the root node as parameter.

2. Step 2: Match method signature options

   void PreorderTraversal(Node root) matches void return type and takes Node root parameter, which is correct.

3. Final Answer:

   void PreorderTraversal(Node root) -> Option A

4. Quick Check:

   Traversal method usually void with root parameter [OK]

Hint: Traversal methods usually return void and take root node [OK]

Common Mistakes:

• Using return type int instead of void
• Not passing root node as parameter
• Using method without parameters

3. Given the following binary tree:

    1
   / \
  2   3
 / \
4   5

What is the output of a preorder traversal printing node values?

medium

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

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

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

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

Solution

1. Step 1: Start preorder traversal at root node 1

   Visit root 1 first.

2. Step 2: Traverse left subtree of 1

   Visit node 2, then its left child 4, then right child 5.

3. Step 3: Traverse right subtree of 1

   Visit node 3.

4. Final Answer:

   [1, 2, 4, 5, 3] -> Option C

5. Quick Check:

   Preorder visits root, left subtree, right subtree [OK]

Hint: Visit root first, then left subtree, then right subtree [OK]

Common Mistakes:

• Mixing preorder with inorder or postorder output
• Visiting left subtree after right subtree
• Skipping leaf nodes

4. Consider this C# preorder traversal method:

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

What is the error in this code?

medium

A. It visits right subtree before left subtree

B. It visits left subtree before root, so not preorder

C. It does not check for null root

D. It prints node values incorrectly

Solution

1. Step 1: Analyze the visiting order in the method

   The method calls Preorder on left child first, then prints root value, then calls Preorder on right child.

2. Step 2: Compare with preorder definition

   Preorder requires visiting root first, then left, then right. This code visits left subtree before root, so it is actually inorder traversal.

3. Final Answer:

   It visits left subtree before root, so not preorder -> Option B

4. Quick Check:

   Preorder must print root before children [OK]

Hint: Print root value before recursive calls for preorder [OK]

Common Mistakes:

• Printing after left subtree call instead of before
• Confusing preorder with inorder traversal
• Missing null check (though present here)

5. You want to collect all node values of a binary tree in preorder traversal into a list in C#. Which code snippet correctly does this?

hard

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

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

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

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

Solution

1. Step 1: Understand preorder traversal collection

   Preorder means visit root first, so add root value to list before recursive calls.

2. Step 2: Check order of recursive calls

   After adding root, recursively traverse left subtree, then right subtree.

3. Final Answer:

   Code snippet that adds root value first, then left, then right -> Option A

4. Quick Check:

   Preorder = Add root, then left, then right [OK]

Hint: Add root value before recursive calls for preorder list [OK]

Common Mistakes:

• Adding node value after left subtree call (inorder)
• Adding node value after both subtree calls (postorder)
• Swapping left and right subtree calls