Array Traversal Patterns in DSA Rust

Mental Model

Go through each item in the list one by one to see or change it.

Analogy: Like walking down a row of mailboxes, checking each one in order.

Index:  0    1    2    3    4
Array: [10] -> [20] -> [30] -> [40] -> [50]

Dry Run Walkthrough

Input: array: [10, 20, 30, 40, 50], print each element

Goal: Visit every element in the array from start to end and print it

Step 1: Start at index 0, read value 10

Index:  0↑   1    2    3    4
Array: [10] -> [20] -> [30] -> [40] -> [50]

Why: We begin at the first element to start traversal

Step 2: Move to index 1, read value 20

Index:  0    1↑   2    3    4
Array: [10] -> [20] -> [30] -> [40] -> [50]

Why: Next element to visit in order

Step 3: Move to index 2, read value 30

Index:  0    1    2↑   3    4
Array: [10] -> [20] -> [30] -> [40] -> [50]

Why: Continue visiting elements sequentially

Step 4: Move to index 3, read value 40

Index:  0    1    2    3↑   4
Array: [10] -> [20] -> [30] -> [40] -> [50]

Why: Keep moving forward to cover all elements

Step 5: Move to index 4, read value 50

Index:  0    1    2    3    4↑
Array: [10] -> [20] -> [30] -> [40] -> [50]

Why: Last element to visit in the array

Result:

Index:  0    1    2    3    4↑
Array: [10] -> [20] -> [30] -> [40] -> [50]
Printed values: 10 20 30 40 50

Annotated Code

DSA Rust

fn main() {
    let arr = [10, 20, 30, 40, 50];
    for i in 0..arr.len() {
        // access element at index i
        println!("{}", arr[i]);
    }
}

for i in 0..arr.len() {

loop from first to last index to visit each element

println!("{}", arr[i]);

print the current element at index i

Output

10

20

30

40

50

Complexity Analysis

Time: O(n) because we visit each of the n elements once

Space: O(1) because we only use a few variables regardless of array size

vs Alternative: Compared to random access, traversal is simple and linear; no extra memory or complex steps needed

Edge Cases

empty array

loop does not run, nothing is printed

DSA Rust

for i in 0..arr.len() {

array with one element

loop runs once, prints the single element

DSA Rust

for i in 0..arr.len() {

When to Use This Pattern

When you need to look at or change every item in a list in order, use array traversal to visit each element one by one.

Common Mistakes

Mistake: Using wrong loop bounds causing index out of range error
Fix: Use 0..arr.len() to safely cover all valid indices

Summary

It goes through each element in an array one by one.

Use it when you want to check or process every item in order.

The key is to start at the first element and move step-by-step to the last.

Practice

1. What does the following Rust code snippet do?
for i in 0..5 { println!("{}", i); }

easy

A. Prints numbers from 1 to 4

B. Prints numbers from 1 to 5

C. Prints numbers from 0 to 5

D. Prints numbers from 0 to 4

Solution

1. Step 1: Understand the range syntax 0..5

   The range 0..5 in Rust includes numbers starting at 0 up to but not including 5.

2. Step 2: Trace the loop iterations

   The loop variable i takes values 0, 1, 2, 3, and 4, printing each number.

3. Final Answer:

   Prints numbers from 0 to 4 -> Option D

4. Quick Check:

   Range 0..5 excludes 5, so output is 0 to 4 [OK]

Hint: Remember Rust ranges exclude the end number [OK]

Common Mistakes:

• Thinking 0..5 includes 5
• Confusing 0..5 with 0..=5
• Assuming loop starts at 1

2. Which of the following is the correct syntax to iterate over the indices of an array arr in Rust?

easy

A. for i in 0..arr.len() { println!("{}", arr[i]); }

B. for i in 0..arr { println!("{}", i); }

C. for i in arr { println!("{}", i); }

D. for i in arr.len() { println!("{}", i); }

Solution

1. Step 1: Check valid iteration over array indices

   Rust arrays have a length method .len(), so 0..arr.len() gives valid indices.

2. Step 2: Access elements by index

   Using arr[i] inside the loop accesses each element correctly.

3. Final Answer:

   for i in 0..arr.len() { println!("{}", arr[i]); } -> Option A

4. Quick Check:

   Use 0..arr.len() for index-based iteration [OK]

Hint: Use arr.len() for array length, not arr alone [OK]

Common Mistakes:

• Using 0..arr instead of 0..arr.len()
• Trying to iterate directly over arr without reference
• Using arr.len() without range syntax

3. What is the output of this Rust code?

let arr = [10, 20, 30];
for i in (0..arr.len()).rev() {
    print!("{} ", arr[i]);
}

medium

A. 10 20 30

B. 0 1 2

C. 30 20 10

D. Compilation error

Solution

1. Step 1: Understand the range and reverse

   The range 0..arr.len() is 0..3, which is 0,1,2. Using .rev() reverses it to 2,1,0.

2. Step 2: Print elements in reverse order

   arr[2] = 30, arr[1] = 20, arr[0] = 10, so output is "30 20 10 "

3. Final Answer:

   30 20 10 -> Option C

4. Quick Check:

   Reverse iteration prints elements backward [OK]

Hint: Use .rev() to reverse range iteration [OK]

Common Mistakes:

• Forgetting .rev() reverses the order
• Printing indices instead of array values
• Confusing range end with inclusive

4. Identify the error in this Rust code snippet that tries to print all elements of an array arr:

let arr = [1, 2, 3];
for i in 0..arr.len() {
    println!("{}", arr[i+1]);
}

medium

A. Syntax error due to missing semicolon

B. Index out of bounds error at runtime

C. No error, prints all elements correctly

D. Compilation error due to type mismatch

Solution

1. Step 1: Analyze the loop indices and access

   The loop runs i from 0 to 2 (arr.len()=3). Accessing arr[i+1] means indices 1,2,3.

2. Step 2: Identify out of bounds access

   arr[3] does not exist, causing runtime panic (index out of bounds).

3. Final Answer:

   Index out of bounds error at runtime -> Option B

4. Quick Check:

   Accessing arr[i+1] exceeds array length [OK]

Hint: Check array indices carefully to avoid out of bounds [OK]

Common Mistakes:

• Assuming arr[i+1] is safe for all i
• Ignoring runtime panics
• Confusing compile-time and runtime errors

5. Given a Rust array arr of integers, which code snippet correctly prints only the even-indexed elements (0, 2, 4, ...) of the array?

hard

A. for i in (0..arr.len()).step_by(2) { println!("{}", arr[i]); }

B. for i in 0..arr.len() { if i % 2 == 1 { println!("{}", arr[i]); } }

C. for i in 0..arr.len() { println!("{}", arr[i * 2]); }

D. for i in (0..arr.len()).rev().step_by(2) { println!("{}", arr[i]); }

Solution

1. Step 1: Understand step_by usage

   The method step_by(2) skips every second index, so 0, 2, 4, ...

2. Step 2: Confirm correct element access

   Using arr[i] inside the loop prints elements at even indices correctly.

3. Final Answer:

   for i in (0..arr.len()).step_by(2) { println!("{}", arr[i]); } -> Option A

4. Quick Check:

   step_by(2) iterates over even indices [OK]

Hint: Use step_by(2) to jump every two elements [OK]

Common Mistakes:

• Using i % 2 == 1 instead of 0 for even indices
• Multiplying i by 2 causing out of bounds
• Using rev() which reverses order unnecessarily