Two-Dimensional and Jagged Arrays

New words in this topic, in plain English. Come back here whenever one feels fuzzy.

Two-dimensional (2D) array

An array of arrays, used like a table with rows and columns.

Row

One inner array of a 2D array, reached with one index, like grid[1].

Column

The position within a row, the second index in grid[row][col].

Jagged array

A 2D array whose rows have different lengths. Java allows it because each row is a separate array.

Row-major order

Visiting a grid row by row: all of row 0, then all of row 1, and so on.

Matrix

A rectangular grid of numbers, where every row has the same length.

Deep copy

A copy where every nested array (each row) is copied too, so nothing is shared with the original.

1. 1

   Swap two rows

   In "A grid", swap rows 0 and 1 of seats with three lines (int[] tmp = seats[0]; seats[0] = seats[1]; seats[1] = tmp;). Print with deepToString. Notice no element was copied: only two references moved.

2. 2

   Print a 2D array the wrong way

   Print Arrays.toString(grid) instead of deepToString. You'll see three [I@... entries, one reference per row. Switch back.

3. 3

   Forget to create a row

   In the Pascal example, comment out tri[r] = new int[r + 1]; and predict the error before running. Then restore it.

Errors are the best teachers. Make each change, read the error, guess what went wrong, then reveal the answer.

public class Main {
    public static void main(String[] args) {
        int[][] grid = new int[3][];
        grid[1][0] = 5;
    }
}

public class Main {
    public static void main(String[] args) {
        int[][] grid = new int[3][2];
        for (int r = 0; r < grid.length; r++) {
            for (int c = 0; c < grid.length; c++) {
                grid[r][c] = r + c;
            }
        }
    }
}

1. 1

   int[][] grid = new int[3][4]; makes 3 rows of 4 columns, all zeros. Read and write with two indexes: grid[row][col]. grid.length is the number of rows; grid[r].length is the number of columns in row r.

2. 2

   Under the hood, grid refers to an outer array of 3 references, and each reference points to a separate int[4] row array on the heap. So grid[1] is itself an int[] you can pass around, print with Arrays.toString, or replace.

3. 3

   Because rows are separate arrays, they can have different lengths: a jagged array. new int[3][] creates only the outer array with three null rows; you create each row yourself, for example tri[r] = new int[r + 1].

4. 4

   The usual way to visit every element is row by row with nested loops: the outer loop over r < grid.length, the inner loop over c < grid[r].length. Using grid[r].length (not grid[0].length) makes the loop correct for jagged arrays too.

5. 5

   Initializers nest: int[][] seats = {{1, 2, 3}, {4, 5, 6}};. Print with Arrays.deepToString, compare with Arrays.deepEquals. And remember: clone() on a 2D array copies only the outer array, so the rows are shared (a shallow copy).

6. 6

   Grids are everywhere in problems: game boards, images, spreadsheets, maps, dynamic programming tables. The DSA course works with them in its Arrays and Dynamic Programming modules (/dsa/arrays, /dsa/dp-grids).

• ↔

  int[][] is easy to read (grid[r][c]) and supports jagged rows, but costs an object per row and may scatter rows in memory. A flat int[] with index arithmetic is faster and smaller for big rectangular grids, at some cost in readability.

• ↔

  Jagged arrays save memory when row sizes really differ (triangles, adjacency lists), but every loop must use each row's own length.

• Done when you can create, fill and print a 2D array with deepToString.

• Done when you can draw the outer array and row arrays of a 2D array in memory.

• Done when you can build a jagged array and loop over it safely.

• Done when you can explain shallow vs deep copies of 2D arrays and write a deep copy.

• Done when you can use deepEquals correctly.