用一维数组对C中的矩阵进行转置

我有一个由一维数组表示的矩阵

例如：

矩阵

 0  1  2  3
 4  5  6  7 
 8  9 10 11

阵列

0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11

现在给出这个矩阵的维数和我想找到转置的数组，即

0, 4, 8, 1, 5, 9, 2, 6, 10, 3, 7, 11

我在C语言中工作，这是我的代码

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

void transpose(int *array, int m, int n){
    int new_array[12];
    for (int i=0; i<m*n; i++) {
        new_array[i] = ??;
    }
    for (int i=0; i<m*n; i++) {
        array[i] = new_array[i];
    }
}

void print_array(int array[], int size){
    for (int i=0; i<size; i++) {
        printf("%d\n",array[i]);
    }
}

int main(){
    int array[12];
    for (int i=0; i<12; i++) {
        array[i]=i;
    }

    print_array(array,12);
    transpose(array,3,4);
    print_array(array,12);

    return 0;
}

#包括
#包括
无效转置（int*数组，int m，int n）{
int新_数组[12]；
对于（int i=0；ii），我已更改：

for (int i = 0 ; i < m*n ; i++) {
    new_array[i] = ??;
}

for（int i=0；i

致：

int-ctr=0；
for（int i=0；i m*n）
ctr-=m*n-1；
新_数组[i]=数组[ctr]；
ctr+=n；
}

逻辑非常简单。每一行都是
n
整数，因此二维矩阵形式中a
num
下面的数字将是
n+num
使用两个
for
循环，使代码更容易理解

void transpose(int *array, int m, int n){

    int new_array[12];
    for (int i = 0; i < m; ++i )
    {
       for (int j = 0; j < n; ++j )
       {
          // Index in the original matrix.
          int index1 = i*n+j;

          // Index in the transpose matrix.
          int index2 = j*m+i;

          new_array[index2] = array[index1];
       }
    }

    for (int i=0; i<m*n; i++) {
        array[i] = new_array[i];
    }
}

void转置（int*array，int m，int n）{
int新_数组[12]；
对于（int i=0；i对于（int i=0；i用范围[0..n]和[0..m]上的双循环写入转置，并计算对应于旧位置和新位置的索引：

#include <stdio.h>

static void transpose(int *array, int m, int n)
{
    int new_array[m * n];
    for (int i = 0; i < m; i++)
    {
        for (int j = 0; j < n; j++)
        {
            int old_idx = i * n + j;
            int new_idx = j * m + i;
            new_array[new_idx] = array[old_idx];
        }
    }
    for (int i = 0; i < m * n; i++)
    {
        array[i] = new_array[i];
    }
}

static void print_array(int array[], int size)
{
    for (int i = 0; i < size; i++)
    {
        printf(" %d", array[i]);
    }
    putchar('\n');
}

int main(void)
{
    int array[12];
    for (int i = 0; i < 12; i++)
    {
        array[i] = i;
    }

    print_array(array, 12);
    transpose(array, 3, 4);
    print_array(array, 12);

    return 0;
}

你差一点就成功了，我想这就够了

void transpose(int *array, int m, int n){
    int new_array[12];
    int count;

    count = 0;
    for (int i=0; i < n; i++) {
        for (int j=0; j < m; j += n) {
            new_array[count++] = i + j;
        }
    }

    for (int i=0; i < m * n; i++) {
        array[i] = new_array[i];
    }
}

void转置（int*array，int m，int n）{
int新_数组[12]；
整数计数；
计数=0；
对于（int i=0；i
无效转置（int*数组、int m、int n）{
int新_数组[12]；
int k=0；
对于（int i=0；i对于（int i=0；i你可以像这样重写你的转置函数：

static void transpose(int *array, int m, int n)
{
    int *temp=malloc(m*n*sizeof(int));     //need to create a temporary array. 
    memcpy(temp,array,m*n*sizeof(int));
    int i, j;

    for (i = 0; i < m; ++i) 
    {
        for (j = 0; j < n; ++j)
        {
            array[j*m+i]=temp[i*n+j];
        }
    }

    free(temp);
}

静态无效转置（int*数组、int m、int n）
{
int*temp=malloc（m*n*sizeof（int））；//需要创建一个临时数组。
memcpy（temp，array，m*n*sizeof（int））；
int i，j；
对于（i=0；i
此算法适用于任意数量的行和列：

（std:：size\u t i=0；i{
对于（std:：size_t j=0；j
在转置函数中，如果您这样声明
新数组
，则绝对没有理由将
m
和
n
作为参数传递。相反，请执行
新数组[n*m]
更合理的是，他们不公平地回头看我，然后不描述你在做什么。@JonathanLeffler在我看来，这个答案早于你的答案。虽然我同意，但没有详细的解释。@JonathanLeffler，正如他们所说的-伟人所见略同：）：）@JonathanLeffler，我认为上面的注释
index1
和
index2
已经足够解释了。不？是的，也许……我最有趣的是，除了索引变量名，我们有相同的操作代码。像“你没有让它与其他大小的数组一起工作”或“你没有显示示例输出”之类的吹毛求疵正是这些-吹毛求疵。你试过了吗？你的意思是使用
新数组[count++]=array[i+j]；
？即使你确实想从数组中复制，这也不是正确的表达式。
void transpose(int *array, int m, int n){
    int new_array[12];
    int count;

    count = 0;
    for (int i=0; i < n; i++) {
        for (int j=0; j < m; j += n) {
            new_array[count++] = i + j;
        }
    }

    for (int i=0; i < m * n; i++) {
        array[i] = new_array[i];
    }
}

void transpose(int *array, int m, int n){
    int new_array[12];
    int k = 0;
    for(int i = 0; i < n; i++){
        for (int j = 0; j < m; j++){
            new_array[k++] = array[j*n + i];
        }
    }
    for (int i=0; i<m*n; i++) {
        array[i] = new_array[i];
    }
}

static void transpose(int *array, int m, int n)
{
    int *temp=malloc(m*n*sizeof(int));     //need to create a temporary array. 
    memcpy(temp,array,m*n*sizeof(int));
    int i, j;

    for (i = 0; i < m; ++i) 
    {
        for (j = 0; j < n; ++j)
        {
            array[j*m+i]=temp[i*n+j];
        }
    }

    free(temp);
}