Tree Traversal Preorder Root Left Right in DSA C - Interactive Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to print the root node's value in preorder traversal.

DSA C

void preorder(struct Node* root) {
    if (root == NULL) return;
    printf("%d ", root->[1]);
}

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

Anext

Bleft

Cright

Ddata

Attempts:

3 left

💡 Hint

Common Mistakes

Trying to print root->left or root->right instead of root->data.

Using an incorrect field name like 'next'.

The preorder traversal visits the root node first, so we print root->data.

2fill in blank

medium

Complete the code to recursively traverse the left subtree in preorder.

DSA C

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

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

Aleft

Bnext

Cparent

Dright

Attempts:

3 left

💡 Hint

Common Mistakes

Calling preorder on root->right before root->left.

Using an invalid pointer like 'parent' or 'next'.

In preorder traversal, after visiting the root, we visit the left subtree first using root->left.

3fill in blank

hard

Fix the error in the code to correctly traverse the right subtree in preorder.

DSA C

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

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

Aright

Bleft

Cparent

Dnext

Attempts:

3 left

💡 Hint

Common Mistakes

Calling preorder on root->left twice.

Using invalid pointers like 'parent' or 'next'.

After traversing the left subtree, preorder traversal visits the right subtree using root->right.

4fill in blank

hard

Fill both blanks to complete the preorder traversal function visiting root, left, then right.

DSA C

void preorder(struct Node* root) {
    if (root == NULL) return;
    printf("%d ", root->[1]);
    preorder(root->[2]);
    preorder(root->right);
}

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

Adata

Bleft

Cright

Dnext

Attempts:

3 left

💡 Hint

Common Mistakes

Printing root->left or root->right instead of root->data.

Traversing right subtree twice or missing left subtree traversal.

First print root->data, then recursively traverse the left subtree with root->left, and finally the right subtree.

5fill in blank

hard

Fill all three blanks to implement preorder traversal visiting root, left, then right.

DSA C

void preorder(struct Node* root) {
    if (root == NULL) return;
    printf("%d ", root->[1]);
    preorder(root->[2]);
    preorder(root->[3]);
}

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

Adata

Bleft

Cright

Dparent

Attempts:

3 left

💡 Hint

Common Mistakes

Using 'parent' pointer which does not exist or is incorrect here.

Swapping left and right subtree traversal order.

Preorder traversal visits the root node's data, then recursively visits the left subtree, then the right subtree.

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