在C中使用指针转置矩阵

Question

I was doing the assignment to use pointer to transpose matrices. My code can successfully transpose the first row of the matrix but fail to transpose other rows and columns. I suspect there's some problems with for loops but I cannot find where the problem is. The following attached is my code.

void transposeMatrix(int matrix[ROWS][COLS]){
    int**  transpose=(int **)malloc(ROWS*sizeof(int*));
    for(int  i=0; i< ROWS; i++)
        transpose[i]=(int*)malloc(COLS*sizeof(int));

    for(int  i=0; i<ROWS;i++){
        puts("");
        for(int  j=0; j<COLS;j++){
            *(transpose+i*ROWS+j)= *(matrix+j*COLS+i);
            printf("%d ",transpose[j][i]);
        }
        puts("");
    }
}

The matrix generates random numbers and the problems looks like this:

Original Matrix:
10 20 30
40 50 60
70 80 90

Transpose Matrix:
10 0 43009213
20 3401401 910429
30 0 134910124

I cannot attach the image so the above is just an elaboration of the problem I faced, the real situation is not exactly like that but very similar.

Thank you for your help!

Answer 1

*(transpose+i*ROWS+j) is not the correct way to access elements of an array of pointers. That's the way to access a 2-dimensional array that's stored contiguously in row-major order in an int[] array or through an int* pointer.

The way to access an element of a 2-dimensional array that's implemented as an array of pointers is with *(*(transpose + i)+j) . *(transpose + i) returns the pointer to row i , adding j to that returns the address of the j 'th column in the row, and deferencing that gets or sets the value.

This will also work with an array declared as

int matrix[ROWS][COLS];

because of the way arrays decay to pointers.

So your assignment line should be:

        *(*(transpose + i)+j) = *(*(matrix + j)+i);

Then you need to change the printf() line, because it's not printing the same element you just assigned. It should be:

        printf("%d ", transpose[i][j]);

The full working function is:

void transposeMatrix(int matrix[ROWS][COLS]){
    int**  transpose=(int **)malloc(ROWS*sizeof(int*));
    for(int  i=0; i< ROWS; i++)
        transpose[i]=(int*)malloc(COLS*sizeof(int));

    for(int  i=0; i<ROWS;i++){
        puts("");
        for(int  j=0; j<COLS;j++){
            *(*(transpose + i)+j) = *(*(matrix + j)+i);
            printf("%d ",transpose[i][j]);
        }
        puts("");
    }
}

Answer 2

You have problem with identifying memory location for row and col of each cells Here is the way using them:

i-th rows of transpose = *(transpose + i)
j-th col in i-th row of transpose  = *(*(transpose+i) + j)

Similar to matrix:

i-th rows of matrix= *(matrix + i)
j-th col in i-th row of matrix  = *(*(matrix+i) + j)

So here is my solution:

void transposeMatrix(int matrix[ROWS][COLS]) {
    int**  transpose = (int **)malloc(ROWS * sizeof(int*));
    for (int i = 0; i < ROWS; i++)
        transpose[i] = (int*)malloc(COLS * sizeof(int));

    for (int i = 0; i < ROWS; i++) {
        puts("");
        for (int j = 0; j < COLS; j++) {
            *(*(transpose + i) + j) = *(*(matrix + j) + i);
            printf("%d ", transpose[i][j]);
        }
        puts("");
    }
}

Answer 3

It's not necessary for you to allocate a new matrix row by row. Also, the functions that do the transpose and printing can be passed straight int * rather than preshaped arrays like int [3][2] etc.

It's even possible to reshape the matrix in place (ie without allocating new space). If you like I can post example code for that later.

For instance:

#include <stdio.h>
#include <stdlib.h>
#include <memory.h>

int M[2][3] = { {1, 2, 3}, {7, 8, 9} };
int N[3][3] = { {1, 2, 3}, { 4, 5, 6 }, {7, 8, 9} };


int *alloc_transpose(const int *matrix, size_t rows, size_t cols);
void print_matrix(const int *matrix, size_t rows, size_t cols);

int main()
{
    int *t_matrix;
    print_matrix(&M[0][0], 2, 3);
fprintf(stderr, "----\n");
    t_matrix = alloc_transpose(&M[0][0], 2, 3);
    if (t_matrix) {
        print_matrix(t_matrix, 3, 2);
    }
    free(t_matrix);
    t_matrix = alloc_transpose(&N[0][0], 3, 3);
    if (t_matrix) {
    fprintf(stderr, "----\n");
        print_matrix(t_matrix, 3, 3);
    }
    free(t_matrix);
    return 0;
}

void print_matrix(const int *matrix, size_t rows, size_t cols)
{
    size_t r, c;
    for (r = 0; r < rows; r++) {
        for (c = 0; c < cols; c++) {
            printf("%d ", *((matrix + r * cols) + c));
        }
        putchar('\n');
    }
}

int *alloc_transpose(const int *matrix, size_t rows, size_t cols)
{
    int *tm;
    int r, c;       /* relative to transposed matrix */

    tm = malloc(sizeof(int) * cols * rows); /* contiguous is okay */

    if (!tm)
        return NULL;

    for (r = 0; r < rows; r++) {
        for (c = 0; c < cols; c++) {
            *((tm + c * rows) + r) =
                          *((matrix + r * cols) + c);
        }
    }

    return tm;
}