Rows Become Columns

The transpose of a matrix is written with a small T, such as M^T. The first row of the original becomes the first column of the result, the second row becomes the second column, and so on. Here is a 2×4 matrix and its 4×2 transpose:

Follow the number 7. In the original it sits at row 1, column 2. In the transpose it sits at row 2, column 1. Every element simply swaps its two indices, while the diagonal (where row equals column) stays where it is.

Method 1: Matrix Transpose in C with a Second Array

The straightforward approach reads each element of the source and writes it to the swapped position in a new array. The destination is declared with the dimensions reversed. Because source and destination are different arrays, there is no risk of overwriting data you still need, and this method works for any shape.

/* transpose.c - transpose a 2x4 matrix, then a 3x3 in place */
#include <stdio.h>

#define R 2
#define C 4

int main(void)
{
    int m[R][C] = { {1, 2, 3, 4}, {5, 6, 7, 8} };
    int t[C][R];

    for (int i = 0; i < R; i++)
        for (int j = 0; j < C; j++)
            t[j][i] = m[i][j];

    printf("transpose (%dx%d):\n", C, R);
    for (int i = 0; i < C; i++) {
        for (int j = 0; j < R; j++)
            printf("%3d", t[i][j]);
        printf("\n");
    }

    /* In-place transpose of a square matrix: swap above-diagonal pairs */
    int sq[3][3] = { {1, 2, 3}, {4, 5, 6}, {7, 8, 9} };
    for (int i = 0; i < 3; i++)
        for (int j = i + 1; j < 3; j++) {
            int tmp = sq[i][j];
            sq[i][j] = sq[j][i];
            sq[j][i] = tmp;
        }
    printf("square in place:\n");
    for (int i = 0; i < 3; i++) {
        for (int j = 0; j < 3; j++)
            printf("%3d", sq[i][j]);
        printf("\n");
    }
    return 0;
}

$ gcc -std=c11 -Wall -Wextra -o transpose transpose.c
$ ./transpose
transpose (4x2):
  1  5
  2  6
  3  7
  4  8
square in place:
  1  4  7
  2  5  8
  3  6  9

The key statement is t[j][i] = m[i][j];. Both loops still run over the source shape (R rows, C columns), while the assignment flips the indices on the destination. A frequent beginner error is to loop over the destination shape and then read from the wrong indices, which is why it helps to say the rule aloud: “row i, column j goes to row j, column i”.

Method 2: In-Place Transpose for Square Matrices

When the matrix is square (same number of rows and columns) you do not need a second array. Each pair of elements mirrored across the main diagonal just trades places. Look at the second half of the program above. The inner loop starts at j = i + 1, which visits only the cells above the diagonal. Each visit swaps sq[i][j] with its mirror sq[j][i].

In-place transposing cannot work directly on a non-square matrix, because the shape itself changes (2×4 becomes 4×2), so the data no longer fits the same array declaration. Non-square in-place transposes exist, but they require reinterpreting a flat buffer with cycle-following logic, which is beyond this lecture.

Matrix Transpose in Embedded C Programming

Why would firmware need a transpose? A few real situations:

• Display drivers: an LED matrix or an OLED page may expect data column by column, while your font table stores glyphs row by row. A transpose converts between the two.
• Keypad scanning: converting between a row-first table and a column-first table.
• Sensor arrays: data arrives channel-major but your filter wants sample-major.
• Linear algebra: many formulas, such as the least-squares solution, use M^T times M.

A transposed read can also be done without copying anything: instead of building t, simply read m[j][i] where you would have read t[i][j]. That costs no memory, and it is often the smartest solution in a firmware loop. Build the physical copy only when a driver or library demands the new layout.

Common Mistakes and Troubleshooting

Best Practices

• Use named constants for sizes so the reversed declaration is obvious: t[C][R].
• Test with a non-square matrix, because a square test hides shape bugs.
• Check the property that transposing twice returns the original matrix.
• Prefer reading with swapped indices when you only need a transposed view.
• Comment the layout (row-major or column-major) wherever data crosses a driver boundary.

Summary and Key Takeaways

• Transpose swaps rows and columns: t[j][i] = m[i][j].
• An M x N matrix becomes N x M.
• A second array handles any shape; in-place swapping works only for square matrices.
• In the in-place loop the inner index starts at i + 1 to avoid swapping twice.
• A transposed view can often be achieved by just swapping the indices when reading.

Conclusion

The transpose is a small program with a big lesson: your data layout and your loops must agree about which index is the row and which is the column. In the final lecture of this array chapter we step one dimension higher with three-dimensional arrays, then close with a quiz and interview questions for this free embedded C course.

Frequently Asked Questions