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

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of Preorder Traversal on a Simple Binary Tree

What is the output of the preorder traversal (Root, Left, Right) for the following binary tree?

Tree structure:
1
/ \ 2 3
/
4

DSA C

struct Node {
    int data;
    struct Node* left;
    struct Node* right;
};

void preorder(struct Node* root) {
    if (root == NULL) return;
    printf("%d ", root->data);
    preorder(root->left);
    preorder(root->right);
}

// Tree creation omitted for brevity

A 2 4 1 3

B 1 3 2 4

C 4 2 1 3

D 1 2 4 3

💡 Hint

Remember preorder means visit root first, then left subtree, then right subtree.

Preorder traversal visits the root node first, then recursively visits the left subtree, followed by the right subtree. So the order is 1 (root), 2 (left child), 4 (left child's left child), then 3 (right child).

🧠 Conceptual

intermediate

Number of Nodes Visited in Preorder Traversal

Given a binary tree with 7 nodes, how many nodes will be visited during a complete preorder traversal?

A 7

B 6

C 8

D Depends on the tree structure

💡 Hint

Preorder traversal visits every node exactly once.

Preorder traversal visits every node in the tree exactly once, so for 7 nodes, it visits all 7.

🔧 Debug

advanced

Identify the Bug in Preorder Traversal Code

What error will the following preorder traversal code produce when run on a non-empty tree?

DSA C

void preorder(struct Node* root) {
    if (root == NULL) return;
    preorder(root->left);
    printf("%d ", root->data);
    preorder(root->right);
}

A Prints nodes in preorder sequence correctly

B Segmentation fault due to missing base case

C Prints nodes in inorder sequence, not preorder

D Compilation error due to missing semicolon

💡 Hint

Check the order of operations inside the function.

The code visits left subtree first, then prints root, then right subtree, which is inorder traversal, not preorder.

📝 Syntax

advanced

Syntax Error in Preorder Traversal Function

Which option contains a syntax error in the preorder traversal function?

DSA C

void preorder(struct Node* root) {
    if (root == NULL) return;
    printf("%d ", root->data);
    preorder(root->left);
    preorder(root->right);
}

A

void preorder(struct Node* root) {
    if (root == NULL) return
    printf("%d ", root->data);
    preorder(root->left);
    preorder(root->right);
}

B

void preorder(struct Node* root) {
    if (root == NULL) return;
    printf("%d ", root->data);
    preorder(root->left);
    preorder(root->right);
}

C

}
;)thgir>-toor(redroerp    
;)tfel>-toor(redroerp    
;)atad>-toor ," d%"(ftnirp    
;nruter )LLUN == toor( fi    
{ )toor *edoN tcurts(redroerp diov

D

oid preorder(struct Node* root) {
    if (root == NULL) return;
    printf("%d ", root->data);
    preorder(root->left);
    preorder(root->right);
}

💡 Hint

Check for missing semicolons after statements.

Option A is missing a semicolon after 'return' statement causing a syntax error.

🚀 Application

expert

Preorder Traversal Output of Complex Tree

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

Tree structure:
10
/ \ 5 15
/ \ \ 3 7 18
\ 8

A 10 5 7 8 3 15 18

B 10 5 3 7 8 15 18

C 5 3 7 8 10 15 18

D 10 15 18 5 3 7 8

💡 Hint

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

Preorder visits 10 (root), then left subtree (5, 3, 7, 8), then right subtree (15, 18).

Practice

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

easy

A. Root, Left, Right

B. Left, Root, Right

C. Left, Right, Root

D. Right, Root, Left

Solution

1. Step 1: Understand preorder traversal definition

   Preorder traversal visits the root node first, then the left subtree, and finally the right subtree.

2. Step 2: Match the order with options

   Root, Left, Right matches the order Root, Left, Right exactly as defined.

3. Final Answer:

   Root, Left, Right -> Option A

4. Quick Check:

   Preorder = Root, Left, Right [OK]

Hint: Remember preorder starts with root node first [OK]

Common Mistakes:

• Confusing preorder with inorder or postorder
• Swapping left and right subtree order
• Thinking traversal starts with left child

2. Which of the following is the correct C syntax to start a preorder traversal function for a binary tree node named root?

easy

A. void preorder(Node root*) { if(root == NULL) return; ... }

B. void preorder(Node root) { if(root == NULL) return; ... }

C. void preorder(Node *root) { if(root == NULL) return; ... }

D. void preorder(Node *root) { if(root = NULL) return; ... }

Solution

1. Step 1: Check function parameter type

   Binary tree nodes are usually passed as pointers, so Node *root is correct.

2. Step 2: Check null pointer check syntax

   The condition if(root == NULL) correctly checks for null pointer. Assignment = is wrong.

3. Final Answer:

   void preorder(Node *root) { if(root == NULL) return; ... } -> Option C

4. Quick Check:

   Pointer param + null check == void preorder(Node *root) { if(root == NULL) return; ... } [OK]

Hint: Use pointer and '==' for null check in C [OK]

Common Mistakes:

• Passing node by value instead of pointer
• Using assignment '=' instead of comparison '=='
• Incorrect pointer syntax like 'Node root*'

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

    1
   / \
  2   3
 / \
4   5

medium

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

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

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

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

Solution

1. Step 1: Start at root node 1

   Preorder visits root first: 1

2. Step 2: Traverse left subtree of 1

   Visit 2, then left child 4, then right child 5: 2, 4, 5

3. Step 3: Traverse right subtree of 1

   Visit right child 3: 3

4. Final Answer:

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

5. Quick Check:

   Preorder = Root, Left, Right = [1,2,4,5,3] [OK]

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

Common Mistakes:

• Mixing preorder with inorder or postorder
• Visiting children before root
• Swapping left and right subtree order

4. Identify the error in this preorder traversal function and select the fix:

void preorder(Node *root) {
  if(root == NULL) return;
  preorder(root->left);
  preorder(root->right);
  printf("%d ", root->data);
}

medium

A. Add return type 'int' instead of 'void'

B. Change 'root == NULL' to 'root = NULL' in if condition

C. Remove recursive call to right subtree

D. Move printf before recursive calls to print root first

Solution

1. Step 1: Analyze traversal order in code

   Current code prints after left and right calls, which is postorder (Left, Right, Root).

2. Step 2: Fix order to preorder

   Print root data before recursive calls to get Root, Left, Right order.

3. Final Answer:

   Move printf before recursive calls to print root first -> Option D

4. Quick Check:

   Preorder prints root before children [OK]

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

Common Mistakes:

• Printing after recursive calls (postorder)
• Using assignment '=' instead of comparison '=='
• Changing return type unnecessarily

5. You want to collect all node values in preorder traversal into an array instead of printing. Which approach correctly modifies the preorder function in C?

void preorder(Node *root, int *arr, int *index) {
  if(root == NULL) return;
  // What goes here?
}

hard

A. arr[*index] = root->data; (*index)++; preorder(root->right, arr, index); preorder(root->left, arr, index);

B. arr[(*index)++] = root->data; preorder(root->left, arr, index); preorder(root->right, arr, index);

C. preorder(root->left, arr, index); preorder(root->right, arr, index); arr[(*index)++] = root->data;

D. preorder(root->left, arr, index); arr[(*index)++] = root->data; preorder(root->right, arr, index);

Solution

1. Step 1: Understand preorder traversal order

   Preorder visits root first, so store root data before recursive calls.

2. Step 2: Correctly update array and index

   Use arr[(*index)++] = root->data; to store and increment index, then recurse left and right.

3. Final Answer:

   arr[(*index)++] = root->data; preorder(root->left, arr, index); preorder(root->right, arr, index); -> Option B

4. Quick Check:

   Store root first, then left and right [OK]

Hint: Store root data before recursive calls, increment index [OK]

Common Mistakes:

• Storing data after recursive calls (not preorder)
• Incrementing index incorrectly
• Swapping left and right recursive calls