Zigzag Level Order Traversal in DSA Rust - Interactive Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to create a vector for the result levels.

DSA Rust

let mut results: Vec<Vec<i32>> = [1];

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

AVec::new()

Bvec![]

CVec::with_capacity(10)

DVec::default()

Attempts:

3 left

💡 Hint

Common Mistakes

Using Vec::with_capacity without initializing elements.

Using Vec::default which may not be clear for beginners.

We use vec![] to create an empty vector to store levels.

2fill in blank

medium

Complete the code to pop the first node from the queue.

DSA Rust

let node = queue.[1]().unwrap();

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

Apop

Bremove

Cpop_back

Dpop_front

Attempts:

3 left

💡 Hint

Common Mistakes

Using pop() which is for Vec, not VecDeque.

Using pop_back() which removes from the end.

pop_front() removes and returns the first element from the VecDeque queue.

3fill in blank

hard

Fix the error in the code to reverse the current level vector when needed.

DSA Rust

if left_to_right == false {
    current_level.[1]();
}

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

Areverse

Bsort

Crotate_left

Dsort_unstable

Attempts:

3 left

💡 Hint

Common Mistakes

Using sort() which sorts elements instead of reversing.

Using rotate_left() which rotates elements but does not reverse.

reverse() reverses the elements in place, needed for zigzag order.

4fill in blank

hard

Fill both blanks to add children nodes to the queue if they exist.

DSA Rust

if let Some(left) = node.[1] {
    queue.[2](left);
}

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

Aleft

Bright

Cpush_back

Dpush_front

Attempts:

3 left

💡 Hint

Common Mistakes

Using push_front which adds to the front, breaking BFS order.

Accessing right child instead of left in this code block.

We check node.left and push_back to add to the queue's end.

5fill in blank

hard

Fill all three blanks to toggle direction and push right child to queue.

DSA Rust

left_to_right = ![1];
if let Some(right) = node.[2] {
    queue.[3](right);
}

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

Aleft_to_right

Bright

Cpush_back

Dpush_front

Attempts:

3 left

💡 Hint

Common Mistakes

Using push_front which breaks BFS order.

Not toggling the direction variable correctly.

Toggle left_to_right boolean, access right child, and push_back to queue.

Practice

1. What does Zigzag Level Order Traversal of a binary tree mean?

easy

A. Traverse nodes only from right to left at all levels

B. Traverse nodes only from left to right at all levels

C. Traverse nodes randomly without any order

D. Traverse nodes level by level, alternating direction each level

Solution

1. Step 1: Understand level order traversal

   Level order traversal means visiting nodes level by level from top to bottom.

2. Step 2: Add zigzag pattern

   Zigzag means alternating the direction of traversal at each level: left to right, then right to left, and so on.

3. Final Answer:

   Traverse nodes level by level, alternating direction each level -> Option D

4. Quick Check:

   Zigzag = alternate directions [OK]

Hint: Remember zigzag means flip direction every level [OK]

Common Mistakes:

• Thinking traversal is always left to right
• Confusing zigzag with preorder or inorder traversal
• Ignoring direction change at alternate levels

2. Which Rust data structure is best to use for implementing Zigzag Level Order Traversal?

easy

A. HashMap for storing node values

B. VecDeque for efficient front and back operations

C. BinaryHeap for priority ordering

D. LinkedList for random access

Solution

1. Step 1: Identify needed operations

   Zigzag traversal requires adding and removing nodes from both ends efficiently.

2. Step 2: Choose suitable Rust structure

   VecDeque supports push/pop from front and back efficiently, ideal for zigzag traversal.

3. Final Answer:

   VecDeque for efficient front and back operations -> Option B

4. Quick Check:

   VecDeque = double-ended queue [OK]

Hint: Use VecDeque for double-ended queue operations [OK]

Common Mistakes:

• Using HashMap which is unordered
• Using BinaryHeap which is for priority, not order
• Using LinkedList which is inefficient in Rust

3. What is the output of the zigzag level order traversal for this tree?

    1
   / \
  2   3
 / \   \
4   5   6

medium

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

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

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

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

Solution

1. Step 1: Traverse level 0 left to right

   Level 0 nodes: [1]

2. Step 2: Traverse level 1 right to left

   Level 1 nodes: [3, 2]

3. Step 3: Traverse level 2 left to right

   Level 2 nodes: [4, 5, 6]

4. Final Answer:

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

5. Quick Check:

   Zigzag levels alternate direction [OK]

Hint: Alternate direction each level when listing nodes [OK]

Common Mistakes:

• Not reversing order on alternate levels
• Mixing node values in wrong order
• Ignoring missing children in traversal

4. Given this Rust code snippet for zigzag traversal, what is the bug?

let mut left_to_right = true;
while !queue.is_empty() {
    let level_size = queue.len();
    let mut level_nodes = Vec::new();
    for _ in 0..level_size {
        let node = queue.pop_front().unwrap();
        if left_to_right {
            level_nodes.push(node.val);
        } else {
            level_nodes.insert(0, node.val);
        }
        if let Some(left) = node.left {
            queue.push_back(left);
        }
        if let Some(right) = node.right {
            queue.push_back(right);
        }
    }
    left_to_right = !left_to_right;
}

medium

A. Inserting at index 0 in Vec is inefficient; use a deque instead

B. The queue should be cleared each iteration

C. left_to_right flag is never toggled

D. Nodes are pushed to queue incorrectly

Solution

1. Step 1: Analyze insertion in level_nodes

   Inserting at index 0 in a Vec shifts all elements, causing inefficiency.

2. Step 2: Suggest better data structure

   Using a VecDeque allows efficient push_front operations for reverse order.

3. Final Answer:

   Inserting at index 0 in Vec is inefficient; use a deque instead -> Option A

4. Quick Check:

   Vec insert(0) is slow; VecDeque better [OK]

Hint: Avoid Vec insert(0); prefer VecDeque for front insertions [OK]

Common Mistakes:

• Thinking queue needs clearing each level
• Missing toggle of left_to_right flag
• Incorrectly pushing children nodes

5. How would you modify a zigzag level order traversal to return the sum of values at each level instead of nodes themselves?

hard

A. Use a stack instead of queue to store nodes

B. Add node values directly to a global sum without level separation

C. Sum values in level_nodes vector before adding to result

D. Reverse the tree before traversal

Solution

1. Step 1: Collect node values per level

   During traversal, store node values in a temporary vector for each level.

2. Step 2: Calculate sum of level nodes

   Sum all values in the vector before adding the sum to the final result list.

3. Final Answer:

   Sum values in level_nodes vector before adding to result -> Option C

4. Quick Check:

   Sum per level = sum(level_nodes) [OK]

Hint: Sum nodes per level before storing result [OK]

Common Mistakes:

• Summing all nodes without level grouping
• Using stack breaks level order logic
• Reversing tree changes structure, not traversal