Rotate Matrix 90° Clockwise In-Place: Tracing [[1,2,3],[4,5,6],[7,8,9]]

Imagine you are handed a grid of pixels or data values—specifically, our 3$\times$3 matrix —and your system demands it rotated 90° clockwise so that it becomes .

The most intuitive first instinct is to allocate a brand-new 3$\times$3 matrix, loop through the old rows and columns, and copy elements into their new rotated homes. For a tiny 3$\times$3 grid, that extra allocation costs almost nothing. But scale that up to a 4K image buffer or a massive dataset where $n=10,000$, and allocating an entirely duplicate matrix doubles your memory footprint instantly.

In memory-constrained environments, graphics pipelines, or embedded systems, that extra allocation is a luxury you cannot afford. You must perform the rotation in-place—meaning you rearrange the existing elements inside the original memory space without utilizing a second matrix.

Attempting this by blindly swapping values immediately leads to a classic failure mode: overwriting data you still need before you have moved it. Without a structured geometric plan, you end up with a mangled matrix of duplicated numbers and lost values.

When we look at our locked working example matrix , rotating it 90 degrees clockwise means the top row [1, 2, 3] must become the rightmost column, and the bottom row [7, 8, 9] must become the leftmost column. Doing this without allocating a brand-new $3\times 3$ grid feels tricky because direct element-shifting causes overwriting collisions. Instead, we can split the rotation into two simpler geometric reflections: transposing the matrix across its main diagonal, and then reversing each individual row.

To see how this works on our locked example, the transpose operation swaps every element at coordinates (i, j) with (j, i). The main diagonal elements (1, 5, 9) stay firmly in place, while pairs like 2 and 4, 3 and 7, and 6 and 8 swap positions. Once transposed, the grid becomes . At this stage, the columns are correct, but they are arranged from left to right instead of right to left. Reversing each row of this transposed intermediate state instantly snaps the elements into the final expected result of .

Try this: Given the 2x2 matrix [[1, 2], [3, 4]], apply the transpose operation first, then predict what the matrix looks like before the row-reversal step.

To rigorously describe our 90° clockwise in-place rotation for the locked example , we must define coordinate transformations for every element in an $n\times n$ grid. Let $A$ be an $n\times n$ matrix where $A_{i,j}$ denotes the element at row $i$ and column $j$, with indices $0\le i,j<n$. For our 3$\times$3 working example, $n=3$.

The overall 90° clockwise rotation operator $R_{90}$ maps an element's initial position $(i,j)$ to its final position $(i^{\prime },j^{\prime })$:

We achieve this via two sequential matrix operations. First, the transpose operation $T$ swaps elements across the main diagonal ($i\leftrightarrow j$):

Applying $T$ to our working example transforms $A$ into the intermediate transposed state:

Second, the horizontal reversal operator $H$ reflects each row around its vertical center:

Applying $H$ to $T(A)$ completes the rotation, yielding our expected result:

Try this: Using the coordinate mapping formula R_90(A_{i,j}) = A_{j, n - 1 - i}, compute the final destination coordinate for the element currently at row i = 0, column j = 2 in our 3x3 matrix [[1,2,3],[4,5,6],[7,8,9]].

Let us trace our locked example from start to finish. We are given a $3\times 3$ matrix $M$ and need to rotate it $90^{\circ }$ clockwise in-place.

Step 1: Transpose the matrix.
We iterate through the upper triangle where $i<j$ and swap $M[i][j]$ with $M[j][i]$.
- Swap $M[0][1]$ (2) and $M[1][0]$ (4)
- Swap $M[0][2]$ (3) and $M[2][0]$ (7)
- Swap $M[1][2]$ (6) and $M[2][1]$ (8)

After transposing, the intermediate matrix looks like this:

Step 2: Reverse each row.
Next, we iterate through each row and reverse its elements in-place (swap index 0 with index 2).
- Row 0: reverse $[1,4,7]$ to $[7,4,1]$
- Row 1: reverse $[2,5,8]$ to $[8,5,2]$
- Row 2: reverse $[3,6,9]$ to $[9,6,3]$

Try this: Given the 2x2 matrix [[1, 2], [3, 4]], write down the intermediate matrix after completing Step 1 (the transpose operation).

Given the 2 by 2 matrix:

Perform the two-step in-place rotation—first transpose the matrix by swapping elements across the main diagonal, and then reverse each row. What is the resulting 2 by 2 matrix after these two operations?

Now that you have mastered rotating the $3\times 3$ matrix [[1,2,3],[4,5,6],[7,8,9]] into [[7,4,1],[8,5,2],[9,6,3]] via transpose and row-reversal, you possess a structural pattern that applies to other geometric transformations. Instead of memorizing separate coordinate formulas for every angle, you can compose elementary operations—just like functions in algebra. For instance, what if you need to rotate counterclockwise by $90^{\circ }$ instead of clockwise?

Recall that a clockwise rotation is transpose followed by horizontal row reversal. By simply reversing the order of these two steps—or reversing rows first, then transposing—you achieve a $90^{\circ }$ counterclockwise rotation. Let us apply this derived technique to our working $3\times 3$ matrix.

First, reverse each row of our original matrix:

Next, transpose the resulting matrix by swapping elements across the main diagonal ($i\leftrightarrow j$):

This exact output is the $90^{\circ }$ counterclockwise rotation of [[1,2,3],[4,5,6],[7,8,9]]. By recognizing that complex matrix transformations decompose into basic index swaps, you can adapt the in-place pattern to $180^{\circ }$ rotations, vertical flips, or diagonal reflections with zero extra memory overhead.