4.13 Implementing 2D Array Algorithms

Implementing 2D array algorithms means using nested loops to find, count, sum, search, and rearrange values in a grid of data. Every 2D algorithm builds from the same 1D patterns, like min, max, sum, count, predicate checks, shifting, and reversing, applied across rows and columns. For AP Computer Science A, track both the row and column index so you process the right part of the array.

Why This Matters for the AP Computer Science A Exam

2D arrays show up on both the multiple-choice and free-response sections of the AP Computer Science A exam, and one free-response question focuses specifically on writing a method that accesses or manipulates data in a 2D array. To do well, you need to traverse a grid in row-major order, column-major order, or a custom pattern, and then apply a standard algorithm to the right region.

The exam often combines several ideas in one problem. You might find the row with the highest average, count elements that meet a condition, or rearrange a row or column. That means you have to manage nested loops, track indices carefully, and decide whether you are scanning the whole array or just one row, column, or subsection. Tracing code by hand and building a small sample array to test your logic are both useful when an array is not fully defined in the problem.

more resources to help you study

practice multiple choiceFRQ practice & scoringcheatsheetsscore calculator

Key Takeaways

• Use arr.length for the number of rows and arr[row].length for the number of columns in that row; mixing them up is the top source of ArrayIndexOutOfBoundsException.
• Outer loop over rows plus inner loop over columns gives row-major order; swap the loop order for column-major.
• Standard 2D algorithms (min/max, sum/average, count, "at least one," "all elements," duplicates) are 1D patterns applied to the whole array or a designated row, column, or subsection.
• When you need the position of an extreme, track both a row index and a column index, not just the value.
• Shifting, rotating, and reversing rows or columns need careful index handling so you do not overwrite values before using them.
• Cast to double when computing averages if you need decimal precision, since integer division drops the remainder.

Core 2D Array Algorithm Patterns

Traversal Patterns

Every 2D algorithm starts with a traversal. Row-major order goes across each row before moving to the next row, which matches how you read text. The outer loop controls the row, the inner loop controls the column:

</>Java
for (int row = 0; row < arr.length; row++) {
    for (int col = 0; col < arr[row].length; col++) {
        // process arr[row][col]
    }
}

Column-major order goes down each column before moving right. You swap which variable the outer and inner loops control:

</>Java
for (int col = 0; col < arr[0].length; col++) {
    for (int row = 0; row < arr.length; row++) {
        // process arr[row][col]
    }
}

You can also traverse just one row, just one column, or a custom region. The loop order and bounds decide exactly which elements you visit, so set them to match the scope the problem asks for.

Finding Minimum and Maximum

Finding an extreme value is the same idea as in a 1D array: initialize a tracking variable, traverse, and update when you find something more extreme. The only new decision is the scope, which can be the entire array or a designated row, column, or subsection.

</>Java
public static int findMax(int[][] arr) {
    int max = arr[0][0];  // initialize with first element
    for (int row = 0; row < arr.length; row++) {
        for (int col = 0; col < arr[row].length; col++) {
            if (arr[row][col] > max) {
                max = arr[row][col];
            }
        }
    }
    return max;
}

When you need the location of an extreme, not just the value, track both indices:

</>Java
public static int[] findMaxLocation(int[][] arr) {
    int maxRow = 0, maxCol = 0;
    int maxVal = arr[0][0];
    for (int row = 0; row < arr.length; row++) {
        for (int col = 0; col < arr[row].length; col++) {
            if (arr[row][col] > maxVal) {
                maxVal = arr[row][col];
                maxRow = row;
                maxCol = col;
            }
        }
    }
    return new int[]{maxRow, maxCol};
}

Sums and Averages

Sums use the accumulator pattern: start at 0 and add each element. The traversal decides what you are summing, whether that is the entire array, one row, or one column.

</>Java
public static int sumAll(int[][] arr) {
    int total = 0;
    for (int[] row : arr) {
        for (int val : row) {
            total += val;
        }
    }
    return total;
}

public static double[] rowAverages(int[][] arr) {
    double[] avgs = new double[arr.length];
    for (int row = 0; row < arr.length; row++) {
        int sum = 0;
        for (int col = 0; col < arr[row].length; col++) {
            sum += arr[row][col];
        }
        avgs[row] = (double) sum / arr[row].length;
    }
    return avgs;
}

For row averages, divide by the number of columns; for column averages, divide by the number of rows; for the whole array, divide by rows times columns. Cast to double before dividing when you need a decimal result.

Searching and Counting

Linear search in a 2D array means accessing each row and then searching across that row. To check whether a value is present, traverse and return early when you find it.

</>Java
public static boolean contains(int[][] arr, int target) {
    for (int[] row : arr) {
        for (int val : row) {
            if (val == target) {
                return true;
            }
        }
    }
    return false;
}

public static int countGreaterThan(int[][] arr, int threshold) {
    int count = 0;
    for (int[] row : arr) {
        for (int val : row) {
            if (val > threshold) {
                count++;
            }
        }
    }
    return count;
}

The same structure handles "at least one element has a property" (return true on the first match), "all elements have a property" (return false on the first failure), and "how many elements have a property" (increment a counter).

Consecutive Pairs

Some problems ask about adjacent elements. Horizontal pairs compare an element to its right neighbor, so the inner loop stops one short of the last column. Vertical pairs compare an element to the one below it, so the row loop stops one short of the last row.

</>Java
public static int countConsecutivePairs(int[][] arr) {
    int count = 0;
    // horizontal pairs
    for (int row = 0; row < arr.length; row++) {
        for (int col = 0; col < arr[row].length - 1; col++) {
            if (arr[row][col] == arr[row][col + 1]) {
                count++;
            }
        }
    }
    // vertical pairs
    for (int row = 0; row < arr.length - 1; row++) {
        for (int col = 0; col < arr[row].length; col++) {
            if (arr[row][col] == arr[row + 1][col]) {
                count++;
            }
        }
    }
    return count;
}

Shifting, Rotating, and Reversing

Rearranging a row or column needs careful index order so you do not overwrite a value you still need. To shift a row left with wraparound, save the first element first, slide the rest left, then place the saved value at the end.

</>Java
public static void shiftRowLeft(int[][] arr, int row) {
    int first = arr[row][0];
    for (int col = 0; col < arr[row].length - 1; col++) {
        arr[row][col] = arr[row][col + 1];
    }
    arr[row][arr[row].length - 1] = first;  // wrap around

}

Reversing a column uses the two-pointer swap from 1D arrays, working from the top and bottom toward the middle:

</>Java
public static void reverseColumn(int[][] arr, int col) {
    int top = 0;
    int bottom = arr.length - 1;
    while (top < bottom) {
        int temp = arr[top][col];
        arr[top][col] = arr[bottom][col];
        arr[bottom][col] = temp;
        top++;
        bottom--;
    }
}

How to Use This on the AP Computer Science A Exam

Free Response

The 2D array free-response question gives you a scenario, the relevant classes, and a method to write from a specification with examples. Read the examples closely to figure out the exact scope you need: the whole array, one row, one column, or a subsection.

Before you write loops, decide your traversal order. Row-major (for row, then for col) covers most cases. If the method works on columns, either switch the loop order to column-major or fix a column and vary the row. Always use arr.length and arr[row].length for bounds instead of hard-coded numbers so your code works for any size grid.

Code Tracing

For multiple-choice, you often trace nested loops to predict output. Follow the first couple of iterations carefully, write down how the indices change, then apply that pattern to the rest of the grid. If the array is not given, build your own small array (like a 2 by 3) and trace the code on it.

Common Trap

Test the boundary cases. When a method shifts, rotates, or checks neighbors, the first and last rows and columns are where index errors happen. Mentally run your loop at row = 0 and row = arr.length - 1 to confirm you stay in range.

Common Errors and Debugging

Confusing Rows and Columns

</>Java
int[][] arr = new int[3][4];  // 3 rows, 4 columns

// WRONG: loop bounds swapped
for (int row = 0; row < 4; row++) {      // using column count
    for (int col = 0; col < 3; col++) {  // using row count
        arr[row][col] = 0;  // crashes when row = 3
    }
}

// CORRECT: bounds match dimensions
for (int row = 0; row < arr.length; row++) {
    for (int col = 0; col < arr[row].length; col++) {
        arr[row][col] = 0;
    }
}

Missing Bounds Checks on Neighbors

</>Java
// WRONG: no bounds checking
public static int countNeighbors(int[][] grid, int row, int col) {
    int count = 0;
    count += grid[row-1][col];    // crashes if row = 0
    count += grid[row+1][col];    // crashes if row = length - 1
    count += grid[row][col-1];    // crashes if col = 0
    count += grid[row][col+1];    // crashes if col = length - 1
    return count;
}

// CORRECT: check bounds first
public static int countNeighbors(int[][] grid, int row, int col) {
    int count = 0;
    if (row > 0) count += grid[row-1][col];
    if (row < grid.length-1) count += grid[row+1][col];
    if (col > 0) count += grid[row][col-1];
    if (col < grid[row].length-1) count += grid[row][col+1];
    return count;
}

Off-by-One in Region Bounds

</>Java
// WRONG: misses the last row and column of the region
public static int sumRegion(int[][] arr, int r1, int c1, int r2, int c2) {
    int sum = 0;
    for (int r = r1; r < r2; r++) {
        for (int c = c1; c < c2; c++) {
            sum += arr[r][c];
        }
    }
    return sum;
}

// CORRECT: use <= to include the endpoints
public static int sumRegion(int[][] arr, int r1, int c1, int r2, int c2) {
    int sum = 0;
    for (int r = r1; r <= r2; r++) {
        for (int c = c1; c <= c2; c++) {
            sum += arr[r][c];
        }
    }
    return sum;
}

Practice Problems

Problem 1: Write a method that returns true if a 2D array contains a saddle point, an element that is the minimum in its row and the maximum in its column.

</>Java
public static boolean hasSaddlePoint(int[][] arr) {
    for (int row = 0; row < arr.length; row++) {
        // find minimum in this row
        int minCol = 0;
        for (int col = 1; col < arr[row].length; col++) {
            if (arr[row][col] < arr[row][minCol]) {
                minCol = col;
            }
        }
        // check if it is the maximum in its column
        boolean isColMax = true;
        for (int r = 0; r < arr.length; r++) {
            if (arr[r][minCol] > arr[row][minCol]) {
                isColMax = false;
                break;
            }
        }
        if (isColMax) {
            return true;  // found a saddle point
        }
    }
    return false;
}

Problem 2: Find the column with the smallest sum.

</>Java
public static int columnWithMinSum(int[][] arr) {
    int minCol = 0;
    int minSum = sumColumn(arr, 0);
    for (int col = 1; col < arr[0].length; col++) {
        int currentSum = sumColumn(arr, col);
        if (currentSum < minSum) {
            minSum = currentSum;
            minCol = col;
        }
    }
    return minCol;
}

private static int sumColumn(int[][] arr, int col) {
    int sum = 0;
    for (int row = 0; row < arr.length; row++) {
        sum += arr[row][col];
    }
    return sum;
}

Problem 3: Check whether any row is a palindrome (reads the same forwards and backwards).

</>Java
public static boolean hasPalindromeRow(int[][] arr) {
    for (int row = 0; row < arr.length; row++) {
        if (isPalindromeRow(arr[row])) {
            return true;
        }
    }
    return false;
}

private static boolean isPalindromeRow(int[] row) {
    int left = 0;
    int right = row.length - 1;
    while (left < right) {
        if (row[left] != row[right]) {
            return false;
        }
        left++;
        right--;
    }
    return true;
}

Common Misconceptions

• "arr.length gives the number of columns." It gives the number of rows. Use arr[row].length for the number of columns in a given row.
• "Column-major order needs a different array." It uses the same array; you only swap which variable the outer and inner loops control.
• "Changing an enhanced for loop variable changes the array." Assigning a new value to that variable does not change the stored element, so use indexed loops when you need to modify values.
• "I can shift a row by copying elements in any order." Order matters. If you overwrite a value before saving or using it, you lose data, so save the endpoint first or shift in the safe direction.
• "Averages will keep their decimals automatically." Integer division drops the remainder. Cast to double before dividing when you need a precise average.
• "Every 2D problem needs a brand-new algorithm." Most are 1D patterns (min, max, sum, count, search, reverse) applied to a row, column, or subsection of the grid.

Related AP Computer Science A Guides

• 4.11 2D Arrays
• 4.15 Sorting
• 4.1 Ethical and Social Implications
• 4.9 Traversing ArrayLists
• 4.5 Developing Algorithms Using Arrays
• 4.16 Recursion