C Matrix Transpose Program
Definition
What Is Matrix Transpose?
The transpose of a matrix flips it across the diagonal: rows become columns. If A is m × n, then AT is n × m and (AT)[i][j] = A[j][i].
A (2 × 3) Aᵀ (3 × 2)
[ 1 2 3 ] [ 1 4 ]
[ 4 5 6 ] → [ 2 5 ]
[ 3 6 ]
Rule: (Aᵀ)[i][j] = A[j][i]
Also: (Aᵀ)ᵀ = A
| A shape | Aᵀ shape | Example map |
|---|
2 × 3 | 3 × 2 | A[0][2]=3 → Aᵀ[2][0]=3 |
3 × 3 | 3 × 3 | Square — size unchanged |
1 × 4 | 4 × 1 | Row becomes a column |
Approach
How to Transpose a Matrix in C
Four clear steps — new buffer for any shape, or in-place swaps for squares.
- Read rows
m and columns n of A. - Allocate result of size
n × m (or reuse A if square). - For every
i, j, copy A[i][j] into result[j][i]. - For square in-place: swap
A[i][j] with A[j][i] when i < j.
| Method | Idea | Time | Best for |
|---|
| New buffer | result[j][i] = A[i][j] | O(m × n) | Any shape, interviews |
| In-place square | Swap above-diagonal pairs | O(n²) | Square matrices, less memory |
Pseudocode
function Transpose(A):
m = rows of A
n = cols of A
T = new matrix[n][m]
for i from 0 to m - 1:
for j from 0 to n - 1:
T[j][i] = A[i][j]
return T
Reference
Cheat Sheet
Keep these facts handy while writing the program.
| Topic | Detail |
|---|
| Rule | (Aᵀ)[i][j] = A[j][i] |
| Shape | m × n → n × m |
| Twice | (Aᵀ)ᵀ = A |
| In-place | Square only (simple form) |
| Indexing | Write to [j][i], read from [i][j] |
| Classic check | {{1,2,3},{4,5,6}}ᵀ = {{1,4},{2,5},{3,6}} |
Try it
Live Preview
Pick a sample matrix to see A and its transpose Aᵀ.
Trace
Worked Walkthrough — 2×3
Copy each A[i][j] into T[j][i].
A = [1 2 3]
[4 5 6]
T is 3 × 2 (zeros first)
A[0][0]=1 → T[0][0]=1
A[0][1]=2 → T[1][0]=2
A[0][2]=3 → T[2][0]=3
A[1][0]=4 → T[0][1]=4
A[1][1]=5 → T[1][1]=5
A[1][2]=6 → T[2][1]=6
T = [1 4]
[2 5]
[3 6]
Code
C Programs
Start with a new-buffer transpose that works for any shape. Use in-place swaps when the matrix is square and memory matters.
Example 1 — New Buffer
Create an n × m result and set result[j][i] = A[i][j].
#include <stdio.h>
#define ROWS 2
#define COLS 3
void transpose(int a[ROWS][COLS], int t[COLS][ROWS])
{
int i, j;
for (i = 0; i < ROWS; i++)
{
for (j = 0; j < COLS; j++)
{
t[j][i] = a[i][j];
}
}
}
void print_transpose(int t[COLS][ROWS])
{
int i, j;
for (i = 0; i < COLS; i++)
{
for (j = 0; j < ROWS; j++)
{
printf("%d ", t[i][j]);
}
printf("\\n");
}
}
int main(void)
{
int a[ROWS][COLS] = { { 1, 2, 3 }, { 4, 5, 6 } };
int t[COLS][ROWS];
transpose(a, t);
print_transpose(t);
return 0;
}
How It Works
ROWS = 2 and COLS = 3 describe the input shape.- Allocate
t with shape COLS × ROWS (swapped dimensions). - Outer loop walks original rows; inner loop walks original columns.
- Write each value to the swapped index:
t[j][i] = a[i][j]. - A
2×3 input becomes a 3×2 output.
Example 2 — In-Place Square
For an n × n matrix, swap above-diagonal pairs — no second matrix needed.
#include <stdio.h>
#define N 3
void transpose_in_place(int a[N][N])
{
int i, j, temp;
for (i = 0; i < N; i++)
{
for (j = i + 1; j < N; j++)
{
temp = a[i][j];
a[i][j] = a[j][i];
a[j][i] = temp;
}
}
}
int main(void)
{
int a[N][N] = {
{ 1, 2, 3 },
{ 4, 5, 6 },
{ 7, 8, 9 }
};
int i, j;
transpose_in_place(a);
for (i = 0; i < N; i++)
{
for (j = 0; j < N; j++)
{
printf("%d ", a[i][j]);
}
printf("\\n");
}
return 0;
}
How It Works
- This form only works for square
N × N matrices. - Loop
i from 0 to N-1. - For each
i, only visit j > i (above the diagonal). - Swap
a[i][j] with a[j][i]; the diagonal stays put. - Result: rows become columns inside the same array.
Edge Cases & Pitfalls
Check these before calling the solution done.
RectangularSize changes
m × n becomes n × m — allocate the new shape.
In-placeSquare only
Simple swaps cannot resize a rectangular matrix.
Index swap[j][i] not [i][j]
Writing to the wrong order leaves the matrix unchanged or wrong.
DiagonalStays put
In-place: never swap a cell with itself (i == j).
Analysis
Time and Space Complexity
| Program | Time | Extra space |
|---|
| New buffer | O(m × n) | O(m × n) for result |
| In-place square | O(n²) | O(1) |
Every entry is read and written once. In-place only saves memory when the matrix is square.
Remember
Key Takeaways
Rule: (Aᵀ)[i][j] = A[j][i].
Shape: m × n becomes n × m.
In-place: square only — swap i < j pairs.
Test: {{1,2,3},{4,5,6}}ᵀ → {{1,4},{2,5},{3,6}}.
One line: flip rows into columns with T[j][i] = A[i][j].
Frequently Asked Questions
The transpose Aᵀ flips A across its diagonal: rows become columns. If A is m × n, then Aᵀ is n × m, and (Aᵀ)[i][j] = A[j][i].
No. An n × n matrix stays n × n. A rectangular m × n matrix becomes n × m.
Yes for square matrices by swapping A[i][j] with A[j][i] for i < j. Rectangular matrices need a new array (or a different storage scheme).
Transposing twice returns the original matrix: (Aᵀ)ᵀ = A.
You visit every entry once, so time is O(m × n). Extra space is O(m × n) for a new buffer, or O(1) for in-place square transpose.
About the author
Developer, cloud engineer, and technical writer
I write practical tutorials so students and working developers can learn by doing—from databases and APIs to deployment on AWS.
9 people found this page helpful
