4.12 Traversing 2D Arrays

Traversing a 2D array means using nested loops to visit its elements in a set order. The most common pattern is row-major order, where the outer loop moves through rows and the inner loop moves across each row using arr[row][col]. For AP Computer Science A, focus on loop bounds, row and column indices, and whether the traversal order matches the problem.

Why This Matters for the AP Computer Science A Exam

2D array traversal shows up on both the multiple-choice and free-response sections of the AP Computer Science A exam. In multiple-choice, you will often trace nested loops to predict output or figure out the final state of a 2D array. In free-response code writing, you may be asked to write a method that accesses or changes data in a 2D array, and you will need to pick the right traversal order and set correct loop bounds.

The starting point is always row-major order, but the same nested structure can be modified to traverse column-major or in nonstandard ways. When you change the order, you also have to adjust the bounds of your loops, so practicing those adjustments and testing boundary conditions makes these questions much more reliable.

more resources to help you study

practice multiple choiceFRQ practice & scoringcheatsheetsscore calculator

Key Takeaways

• Nested loops traverse a 2D array; the outer loop usually handles rows and the inner loop handles columns.
• Row-major order goes across each row in turn; column-major order goes down each column by swapping which index the loops control.
• Use arr.length for the number of rows and arr[row].length for the number of columns in a row.
• With nested enhanced for loops, the outer variable is a 1D array (a whole row) and the inner variable is a single element.
• Assigning a new value to an enhanced for loop variable does not change the array, so use indices when you need to modify elements.
• Going outside valid index ranges throws an ArrayIndexOutOfBoundsException, so watch your loop bounds.

Row-Major Traversal

Row-major order is the default way to visit every element. The outer loop walks through each row, and the inner loop walks across the columns in that row. This matches how 2D arrays are stored as an array of arrays.

</>Java
public static void traverseByRows(int[][] matrix) {
    // Outer loop: iterate through each row
    for (int row = 0; row < matrix.length; row++) {
        // Inner loop: iterate through each column in current row
        for (int col = 0; col < matrix[row].length; col++) {
            System.out.print(matrix[row][col] + " ");
        }
        System.out.println(); // New line after each row
    }
}

Notice the bounds: matrix.length is the number of rows, and matrix[row].length is the number of columns in that row. Row-major order is a clean way to make sure you visit every element exactly once, which is why it is the most common pattern in problems that sum values, count elements, or print a grid.

Column-Major Traversal

Column-major order visits all of column 0 first, then all of column 1, and so on. You get this by swapping which index each loop controls: the outer loop now runs over columns and the inner loop runs over rows.

</>Java
public static void traverseByColumns(int[][] matrix) {
    if (matrix.length == 0) return;

    // Outer loop: iterate through each column
    for (int col = 0; col < matrix[0].length; col++) {
        // Inner loop: iterate through each row for current column
        for (int row = 0; row < matrix.length; row++) {
            System.out.println(matrix[row][col]);
        }
    }
}

The element access is still matrix[row][col], but the column index stays fixed while the row index changes. This pattern fits problems that organize data by column, like analyzing one test score across every student when each column is a test.

Enhanced For Loops with 2D Arrays

A nested enhanced for loop is a cleaner option when you do not need indices. Because a 2D array is an array of arrays, the outer loop variable is a whole row (a 1D array), and the inner loop variable is a single element.

</>Java
public static int sumAllElements(int[][] matrix) {
    int total = 0;

    // Outer enhanced for loop: each row is a 1D array
    for (int[] row : matrix) {
        // Inner enhanced for loop: each value is an element
        for (int value : row) {
            total += value;
        }
    }

    return total;
}

Two things to remember. First, the types must match: the outer variable is int[] and the inner variable is int. Second, assigning a new value to the enhanced for loop variable does not change what is stored in the array. If you need to know an element's position or modify the array, use index-based loops instead.

</>Java
public static void findMaxPosition(double[][] values) {
    if (values.length == 0 || values[0].length == 0) return;

    double maxValue = values[0][0];
    int maxRow = 0, maxCol = 0;

    // Must use index-based loops to track positions
    for (int row = 0; row < values.length; row++) {
        for (int col = 0; col < values[row].length; col++) {
            if (values[row][col] > maxValue) {
                maxValue = values[row][col];
                maxRow = row;
                maxCol = col;
            }
        }
    }

    System.out.printf("Maximum value %.2f found at position [%d][%d]%n",
                      maxValue, maxRow, maxCol);
}

Custom Traversal Orders

Once you are comfortable with row-major and column-major order, you can adjust the same nested structure to traverse in other ways. Changing the loop bounds or the direction of the inner loop produces patterns like back and forth (boustrophedon) or diagonal traversals. The key is to adjust the bounds carefully and test the edges so you do not step outside valid indices.

</>Java
// Back-and-forth: left-to-right on even rows, right-to-left on odd rows
public static void traverseBackAndForth(int[][] matrix) {
    for (int row = 0; row < matrix.length; row++) {
        if (row % 2 == 0) {
            for (int col = 0; col < matrix[row].length; col++) {
                System.out.print(matrix[row][col] + " ");
            }
        } else {
            for (int col = matrix[row].length - 1; col >= 0; col--) {
                System.out.print(matrix[row][col] + " ");
            }
        }
    }
}

The traversal order can change the result you compute, so read each problem carefully to decide which order fits. For accessing neighbors or border elements, check that each index stays within 0 to length - 1 before you use it.

How to Use This on the AP Computer Science A Exam

Code Tracing

In multiple-choice questions, you will often trace nested loops over a small 2D array. Write out the array as a grid and track the loop variables row by row. For each pass, note which element arr[row][col] refers to and update any running totals or variables. If the array is not given, make a small one (like 2 by 3) and trace the code on it to see the pattern.

Free Response

For code-writing questions involving a 2D array, decide first whether the problem wants row-major, column-major, or a custom order. Then set your bounds: arr.length for rows and arr[row].length for columns. If you need to modify elements, use index-based loops so you can assign with arr[row][col] = value. Test your loop on the corners and edges of the array to catch off-by-one mistakes.

Common Trap

Swapping the row and column indices is the most frequent error. Remember that the first bracket is the row and the second is the column, so arr[row][col] and arr.length (rows) versus arr[row].length (columns) must line up with the order you intend.

Common Misconceptions

• "The outer loop is always columns." The outer loop is whichever dimension you choose. For row-major it is rows; for column-major it is columns. The order you pick changes the traversal.
• "arr.length gives the number of columns." It gives the number of rows. Use arr[row].length for the number of columns in a row.
• "Changing the enhanced for loop variable changes the array." Assigning to that variable only changes the local copy. Use indices to modify the actual array.
• "The outer enhanced for loop variable is a single element." For a 2D array it is a whole row, which is a 1D array. The inner variable is the single element.
• "Row-major and column-major give the same result." They visit elements in different orders, which can change output or any order-dependent computation.
• "Any nested loop will avoid index errors." If your bounds do not match the array's actual rows and columns, you can still get an ArrayIndexOutOfBoundsException. Always check your bounds, especially in custom traversals.

Related AP Computer Science A Guides

• 4.4 Traversing Arrays
• 4.5 Developing Algorithms Using Arrays
• 4.14 Searching
• 4.11 2D Arrays
• 4.13 Implementing 2D Array Algorithms
• 4.1 Ethical and Social Implications