Array Traversal Patterns

Array traversal is the process of accessing each element of an array in a specific order to perform operations such as reading, updating, searching, filtering, or aggregation. Choosing the right traversal pattern improves clarity, correctness, and performance. This topic is frequently tested in interviews and is fundamental to algorithms and data processing.

What Is Array Traversal?

• Visiting array elements one by one
• Can be forward, backward, conditional, or structured
• Applies to 1D and 2D arrays

1. Forward Traversal (Left → Right)

Most common pattern.

int[] arr = {10, 20, 30, 40};
for (int i = 0; i < arr.length; i++) {
    System.out.println(arr[i]);
}
          

Use cases:

• Printing
• Summation
• Validation

2. Backward Traversal (Right → Left)

for (int i = arr.length - 1; i >= 0; i--) {
    System.out.println(arr[i]);
}
          

Use cases:

• Reverse processing
• Stack-like behavior

3. Enhanced for-each Traversal (Read-Only)

for (int value : arr) {
    System.out.println(value);
}
          

Characteristics:

• No index access
• Clean and readable
• Read-only (no structural modification)

4. Conditional Traversal (Filtering)

for (int i = 0; i < arr.length; i++) {
    if (arr[i] % 2 == 0) {
        System.out.println(arr[i]);
    }
}
          

Use cases:

• Filtering even/odd
• Business rule checks

5. Accumulative Traversal (Aggregation)

Sum of Elements

int sum = 0;
for (int value : arr) {
    sum += value;
}
          

Find Maximum / Minimum

int max = arr[0];
for (int i = 1; i < arr.length; i++) {
    if (arr[i] > max) {
        max = arr[i];
    }
}
          

6. Index-Based Traversal (Index Required)

for (int i = 0; i < arr.length; i++) {
    System.out.println("Index " + i + ": " + arr[i]);
}
          

Use cases:

• Position-based logic
• Index-dependent conditions

7. Pairwise Traversal (Adjacent Elements)

for (int i = 0; i < arr.length - 1; i++) {
    System.out.println(arr[i] + " , " + arr[i + 1]);
}
          

Use cases:

• Comparing neighbors
• Detecting sequences

8. Step-Based Traversal (Skip Elements)

for (int i = 0; i < arr.length; i += 2) {
    System.out.println(arr[i]);
}
          

Use cases:

• Alternate elements
• Performance optimizations

9. Nested Traversal (2D Arrays)

int[][] matrix = {
    {1, 2, 3},
    {4, 5, 6}
};
for (int i = 0; i < matrix.length; i++) {
    for (int j = 0; j < matrix[i].length; j++) {
        System.out.print(matrix[i][j] + " ");
    }
    System.out.println();
}
          

10. Row-wise vs Column-wise Traversal (2D)

Row-wise (Default)

for (int i = 0; i < matrix.length; i++) {
    for (int j = 0; j < matrix[i].length; j++) {
        // row-wise
    }
}
          

Column-wise

for (int j = 0; j < matrix[0].length; j++) {
    for (int i = 0; i < matrix.length; i++) {
        // column-wise
    }
}
          

11. Early Exit Traversal (break)

for (int value : arr) {
    if (value == key) {
        System.out.println("Found");
        break;
    }
}
          

Use case: Searching

12. Skip-Based Traversal (continue)

for (int value : arr) {
    if (value < 0) {
        continue;
    }
    System.out.println(value);
}
          

Choosing the Right Traversal Pattern

Common Beginner Mistakes

• Off-by-one errors (< vs <=)
• Using for-each when index is required
• Forgetting length bounds
• Over-nesting loops
• Ignoring early exit opportunities

Interview-Ready Answers

Short Answer

Array traversal is the process of accessing each element of an array in a specific order to perform operations.

Detailed Answer

In Java, arrays can be traversed using forward, backward, enhanced for-each, conditional, and nested traversal patterns. Choosing the correct traversal approach improves readability, performance, and correctness.

Additional Traversal Examples

1. Forward Traversal (Index-Based)

int[] nums = {10, 20, 30, 40};
for (int i = 0; i < nums.length; i++) {
    System.out.println(nums[i]);
}
          

Explanation

• Traverses from first to last element.
• Most common and safest pattern.

2. Reverse Traversal

int[] nums = {10, 20, 30, 40};
for (int i = nums.length - 1; i >= 0; i--) {
    System.out.println(nums[i]);
}
          

Explanation

• Traverses array backward.
• Used in reversal and stack-like logic.

3. Enhanced for-each Traversal

int[] nums = {10, 20, 30};
for (int n : nums) {
    System.out.println(n);
}
          

Explanation

• Clean, readable traversal.
• Read-only (no index access).

4. Skip Elements Using continue

int[] nums = {1, 2, 3, 4, 5};
for (int n : nums) {
    if (n % 2 == 0) continue;
    System.out.println(n);
}
          

Explanation

• Skips even numbers.
• Useful for filtering.

5. Early Exit Using break

int[] nums = {10, 20, 30, 40};
for (int n : nums) {
    if (n == 30) {
        break;
    }
    System.out.println(n);
}
          

Explanation

• Stops traversal when condition is met.
• Improves performance.

6. Conditional Traversal with Flag

int[] nums = {5, 10, 15};
boolean found = false;
for (int n : nums) {
    if (n == 10) {
        found = true;
        break;
    }
}
System.out.println(found);
          

Explanation

• Flag stores result after loop.
• Common interview pattern.

7. Step-Size Traversal (Skip by Index)

int[] nums = {1, 2, 3, 4, 5, 6};
for (int i = 0; i < nums.length; i += 2) {
    System.out.println(nums[i]);
}
          

Explanation

• Accesses every alternate element.
• Useful in pattern logic.

8. Traversal with Modification (Index Required)

int[] nums = {1, 2, 3};
for (int i = 0; i < nums.length; i++) {
    nums[i] = nums[i] * 2;
}
          

Explanation

• Modifies array elements.
• Enhanced for-each cannot do this.

9. Traversal Using while Loop

int[] nums = {10, 20, 30};
int i = 0;
while (i < nums.length) {
    System.out.println(nums[i]);
    i++;
}
          

Explanation

• Manual control of index.
• Useful in conditional scenarios.

10. Traversal Using do-while Loop

int[] nums = {10, 20, 30};
int i = 0;
do {
    System.out.println(nums[i]);
    i++;
} while (i < nums.length);
          

Explanation

• Executes at least once.
• Rare but valid.

11. Nested Traversal of 2D Array (Row-Major)

int[][] matrix = {{1, 2}, {3, 4}};
for (int i = 0; i < matrix.length; i++) {
    for (int j = 0; j < matrix[i].length; j++) {
        System.out.print(matrix[i][j] + " ");
    }
}
          

Explanation

• Standard 2D traversal.
• Row by row.

12. Enhanced Traversal of 2D Array

int[][] matrix = {{1, 2}, {3, 4}};
for (int[] row : matrix) {
    for (int val : row) {
        System.out.println(val);
    }
}
          

Explanation

• Cleaner syntax.
• Best for read-only matrix traversal.

13. Column-Wise Traversal of 2D Array

int[][] matrix = {{1, 2}, {3, 4}};
for (int col = 0; col < matrix[0].length; col++) {
    for (int row = 0; row < matrix.length; row++) {
        System.out.println(matrix[row][col]);
    }
}
          

Explanation

• Fixes column index.
• Used in transpose logic.

14. Diagonal Traversal (Square Matrix)

int[][] matrix = {{1, 2}, {3, 4}};
for (int i = 0; i < matrix.length; i++) {
    System.out.println(matrix[i][i]);
}
          

Explanation

• Accesses diagonal elements.
• Condition: row == column.

15. Reverse Row Traversal (2D Array)

int[][] matrix = {{1, 2}, {3, 4}};
for (int i = matrix.length - 1; i >= 0; i--) {
    for (int j = 0; j < matrix[i].length; j++) {
        System.out.println(matrix[i][j]);
    }
}
          

Explanation

• Traverses rows from bottom to top.

16. Traverse Jagged Array Safely

int[][] jagged = {
    {1, 2},
    {3, 4, 5},
    {6}
};
for (int i = 0; i < jagged.length; i++) {
    for (int j = 0; j < jagged[i].length; j++) {
        System.out.println(jagged[i][j]);
    }
}
          

Explanation

• Each row has different length.
• Always use jagged[i].length.

17. Frequency Count Traversal

int[] nums = {1, 2, 2, 3};
int count = 0;
for (int n : nums) {
    if (n == 2) {
        count++;
    }
}
System.out.println(count);
          

Explanation

• Counts occurrences.
• Common interview problem.

18. Pair Traversal (Combinations)

int[] nums = {1, 2, 3};
for (int i = 0; i < nums.length; i++) {
    for (int j = i + 1; j < nums.length; j++) {
        System.out.println(nums[i] + "," + nums[j]);
    }
}
          

Explanation

• Generates unique pairs.
• Time complexity: O(n²).

19. Two-Pointer Traversal

int[] nums = {1, 2, 3, 4};
int left = 0, right = nums.length - 1;
while (left < right) {
    System.out.println(nums[left] + "," + nums[right]);
    left++;
    right--;
}
          

Explanation

• Used in reversal and searching.
• Efficient pattern.

20. Interview Summary Example (Traversal Pattern)

int[] nums = {10, 20, 30};
for (int i = 0; i < nums.length; i++) {
    System.out.println(nums[i]);
}
          

Explanation

• Demonstrates:
• Index-based traversal
• Safe bounds
• Core array access
• Extremely common interview question.

Key Takeaway

Mastering array traversal patterns enables you to write clean, efficient, and bug-free logic. Most array-based interview problems are simply applications of the right traversal pattern.