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 first in preorder traversal.

DSA C++

void preorder(Node* root) {
    if (root == nullptr) return;
    std::cout << root->[1] << " ";
    preorder(root->left);
    preorder(root->right);
}

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

Adata

Bval

Cvalue

Dkey

Attempts:

3 left

💡 Hint

Common Mistakes

Using 'val' or 'key' which may not exist in the Node structure.

Trying to print the pointer instead of the value.

The root node's data is accessed by 'data' in this Node structure.

2fill in blank

medium

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

DSA C++

void preorder(Node* root) {
    if (root == nullptr) return;
    std::cout << root->data << " ";
    preorder(root->[1]);
    preorder(root->right);
}

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

Achild

Bright

Cnext

Dleft

Attempts:

3 left

💡 Hint

Common Mistakes

Calling preorder on 'right' before 'left'.

Using non-existent members like 'child' or 'next'.

In preorder traversal, after the root, we visit the left subtree first, so we call preorder on 'left'.

3fill in blank

hard

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

DSA C++

void preorder(Node* root) {
    if (root == nullptr) return;
    std::cout << root->data << " ";
    preorder(root->left);
    preorder(root->[1]);
}

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

Aleft

Bchild

Cright

Dnext

Attempts:

3 left

💡 Hint

Common Mistakes

Calling preorder on 'left' twice.

Using invalid member names like 'child' or 'next'.

After visiting the left subtree, preorder traversal visits the right subtree, so we call preorder on 'right'.

4fill in blank

hard

Fill both blanks to complete the preorder traversal function that prints nodes in Root-Left-Right order.

DSA C++

void preorder(Node* root) {
    if (root == nullptr) return;
    std::cout << root->[1] << " ";
    preorder(root->[2]);
    preorder(root->right);
}

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

Adata

Bval

Cleft

Dright

Attempts:

3 left

💡 Hint

Common Mistakes

Swapping 'left' and 'right' in traversal order.

Using 'val' instead of 'data' for the node's value.

We print the root's 'data' first, then recursively traverse the 'left' subtree before the right.

5fill in blank

hard

Fill all three blanks to complete the preorder traversal that prints root, left subtree, then right subtree.

DSA C++

void preorder(Node* root) {
    if (root == nullptr) return;
    std::cout << root->[1] << " ";
    preorder(root->[2]);
    preorder(root->[3]);
}

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

Adata

Bleft

Cright

Dval

Attempts:

3 left

💡 Hint

Common Mistakes

Mixing up the order of left and right traversal.

Using 'val' instead of 'data' for the node's value.

Print the root's 'data', then recursively traverse 'left' subtree, then 'right' subtree.

Practice

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

easy

A. Right, Root, Left

B. Left, Root, Right

C. Left, Right, Root

D. Root, Left, Right

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.

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 before root
• Visiting right before left

2. Which of the following C++ function signatures correctly represents a preorder traversal of a binary tree node Node*?

easy

A. void preorder(Node* root) { if(root) { cout << root->data; preorder(root->left); preorder(root->right); } }

B. void preorder(Node* root) { if(root) { preorder(root->left); preorder(root->right); cout << root->data; } }

C. void preorder(Node* root) { if(root) { preorder(root->right); cout << root->data; preorder(root->left); } }

D. void preorder(Node* root) { if(root) { preorder(root->left); cout << root->data; preorder(root->right); } }

Solution

1. Step 1: Recall preorder traversal order

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

2. Step 2: Check function code order

   void preorder(Node* root) { if(root) { cout << root->data; preorder(root->left); preorder(root->right); } } prints root data first, then recursively visits left and right children, matching preorder.

3. Final Answer:

   void preorder(Node* root) { if(root) { cout << root->data; preorder(root->left); preorder(root->right); } } -> Option A

4. Quick Check:

   Print root first, then left, then right [OK]

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

Common Mistakes:

• Printing after recursive calls (postorder)
• Swapping left and right recursive calls
• Missing null check for root

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

      10
     /  \
    5    15
   /    /  \
  3    12  20

medium

A. [10, 15, 20, 12, 5, 3]

B. [10, 5, 3, 15, 12, 20]

C. [3, 5, 10, 12, 15, 20]

D. [5, 3, 10, 12, 15, 20]

Solution

1. Step 1: Start at root and visit nodes in preorder

   Visit root 10, then left subtree (5, then 3), then right subtree (15, then 12 and 20).

2. Step 2: Write traversal sequence

   Sequence is 10, 5, 3, 15, 12, 20.

3. Final Answer:

   [10, 5, 3, 15, 12, 20] -> Option B

4. Quick Check:

   Preorder = Root, Left, Right = [10,5,3,15,12,20] [OK]

Hint: Follow root, then left subtree, then right subtree order [OK]

Common Mistakes:

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

4. Identify the error in the following preorder traversal function and select the corrected version:

void preorder(Node* root) {
  if(root == nullptr) return;
  preorder(root->left);
  cout << root->data << " ";
  preorder(root->right);
}

medium

A. void preorder(Node* root) { if(root == nullptr) return; cout << root->data << " "; preorder(root->left); preorder(root->right); }

B. void preorder(Node* root) { if(root == nullptr) return; preorder(root->right); cout << root->data << " "; preorder(root->left); }

C. void preorder(Node* root) { if(root == nullptr) return; preorder(root->left); preorder(root->right); cout << root->data << " "; }

D. void preorder(Node* root) { if(root == nullptr) return; cout << root->data << " "; preorder(root->right); preorder(root->left); }

Solution

1. Step 1: Identify preorder traversal order

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

2. Step 2: Check given function and options

   The given function prints after left subtree, which is inorder traversal. void preorder(Node* root) { if(root == nullptr) return; cout << root->data << " "; preorder(root->left); preorder(root->right); } prints root first, then left, then right, matching preorder.

3. Final Answer:

   void preorder(Node* root) { if(root == nullptr) return; cout << root->data << " "; preorder(root->left); preorder(root->right); } -> Option A

4. Quick Check:

   Print root before recursive calls for preorder [OK]

Hint: Print root data before recursive calls to fix preorder [OK]

Common Mistakes:

• Printing after left subtree (inorder)
• Swapping left and right subtree calls
• Missing null pointer check

5. You have a binary tree where some nodes have only one child. How does preorder traversal help in serializing this tree uniquely, and which sequence below represents the preorder traversal of this tree?

       8
      / \
     4   10
      \    \
       6    20

hard

A. [8, 10, 20, 4, 6]

B. [4, 6, 8, 10, 20]

C. [8, 4, 6, 10, 20]

D. [6, 4, 8, 20, 10]

Solution

1. Step 1: Understand preorder traversal for serialization

   Preorder visits root first, then left subtree, then right subtree, capturing structure including nodes with single children.

2. Step 2: Traverse given tree in preorder

   Visit 8 (root), then left subtree: 4, then 6 (right child of 4), then right subtree: 10, then 20 (right child of 10).

3. Step 3: Write traversal sequence

   Sequence is [8, 4, 6, 10, 20].

4. Final Answer:

   [8, 4, 6, 10, 20] -> Option C

5. Quick Check:

   Preorder captures root-left-right including single children [OK]

Hint: Preorder captures tree shape by visiting root before children [OK]

Common Mistakes:

• Ignoring nodes with single child
• Mixing preorder with inorder
• Visiting right subtree before left