采用指针的方法转置二维数组，用函数实现。

可以使用以下函数来实现二维数组的转置：

void transpose(int *arr, int rows, int cols) {
int temp;
for (int i = ; i < rows; i++) {
for (int j = i; j < cols; j++) {
temp = *(arr + i * cols + j);
*(arr + i * cols + j) = *(arr + j * cols + i);
*(arr + j * cols + i) = temp;
}
}
}

其中，arr是指向二维数组的指针，rows和cols分别是数组的行数和列数。在函数中，我们使用两个嵌套的循环来遍历数组，并使用指针来访问数组元素。在每次循环中，我们交换当前元素和对应位置的元素，从而实现了数组的转置。

相关问题

采用指针的方法转置二维数组，用函数实现

### 回答1：
可以使用以下函数来实现二维数组的转置：

void transpose(int *arr, int rows, int cols) {
    int temp;
    for (int i = ; i < rows; i++) {
        for (int j = i + 1; j < cols; j++) {
            temp = *(arr + i * cols + j);
            *(arr + i * cols + j) = *(arr + j * cols + i);
            *(arr + j * cols + i) = temp;
        }
    }
}

其中，`arr` 是指向二维数组的指针，`rows` 和 `cols` 分别表示二维数组的行数和列数。在函数中，我们使用两个嵌套的循环来遍历二维数组，然后交换每个元素的值，以实现转置。

使用该函数的示例代码如下：

#include <stdio.h>

void transpose(int *arr, int rows, int cols);

int main() {
    int arr[3][3] = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}};

    printf("Original array:\n");
    for (int i = ; i < 3; i++) {
        for (int j = ; j < 3; j++) {
            printf("%d ", arr[i][j]);
        }
        printf("\n");
    }

    transpose(&arr[][], 3, 3);

    printf("Transposed array:\n");
    for (int i = ; i < 3; i++) {
        for (int j = ; j < 3; j++) {
            printf("%d ", arr[i][j]);
        }
        printf("\n");
    }

    return ;
}

void transpose(int *arr, int rows, int cols) {
    int temp;
    for (int i = ; i < rows; i++) {
        for (int j = i + 1; j < cols; j++) {
            temp = *(arr + i * cols + j);
            *(arr + i * cols + j) = *(arr + j * cols + i);
            *(arr + j * cols + i) = temp;
        }
    }
}

输出结果如下：

Original array:
1 2 3 
4 5 6 
7 8 9 
Transposed array:
1 4 7 
2 5 8 
3 6 9 

### 回答2：
转置二维数组是指将数组的行和列互换。在C语言中，可以采用指针的方法实现对二维数组的转置。下面简要介绍一下如何使用指针对二维数组进行转置：

1. 定义二维数组和指针变量

在进行二维数组的转置时，首先需要定义一个二维数组和一个指向二维数组的指针变量。假设二维数组的名称为array，指向二维数组的指针变量为p。

int array[ROW][COL];
int (*p)[ROW];

这里的p指向一个长度为ROW的一维数组。

2. 使用指针变量获取数组元素

由于二维数组在内存中是连续存储，可以通过指针来访问每一个元素。使用指针变量p可以获取每一个元素的地址，再通过指针访问该元素的值。假设获取二维数组的i行j列元素，代码如下：

int temp = *(*(array+i)+j);

其中，array+i表示获取二维数组的第i行，指针加j表示获取该行的第j个元素。

3. 将二维数组行列互换

将二维数组的行列互换可以采用双重循环来实现。假设要将二维数组array转置后存储到数组result中，代码如下：

for(int i=0; i<ROW; i++){
for(int j=0; j<COL; j++){
*(*(result+j)+i) = *(*(array+i)+j);
}
}

其中，*(*(result+j)+i)表示将二维数组array的第i行第j列元素存储到result的第j行第i列元素中。

4. 定义转置函数

将上述代码封装成一个函数，供主函数调用，如下所示：

void transpose(int array[ROW][COL], int result[COL][ROW]){
int (*p)[ROW];
p = array;
for(int i=0; i<ROW; i++){
for(int j=0; j<COL; j++){
*(*(result+j)+i) = *(*(p+i)+j);
}
}
}

在主函数中调用该函数即可实现二维数组的转置。

以上就是使用指针的方法实现二维数组的转置，并通过函数来封装的步骤。指针虽然操作起来更加麻烦，但可以有效地提高程序的执行效率。

### 回答3：
转置二维数组是将一个二维数组的行列互换得到一个新的二维数组。采用指针的方法实现转置二维数组可以提高程序的效率和灵活性，而且更具有通用性，可以应用于不同形式和大小的数组。下面是采用指针的方法实现转置二维数组的函数代码：

#include <stdio.h>

#define ROW 3
#define COL 4

void transpose(int (*p)[COL]) //用指向含有COL个元素的一维数组的指针作为函数参数
{
    int temp;
    for(int i=0; i<ROW; i++)
    {
        for(int j=i+1; j<COL; j++)
        {
            temp = *((p+i*COL)+j);
            *((p+i*COL)+j) = *((p+j*COL)+i);
            *((p+j*COL)+i) = temp;
        }
    }
}

int main()
{
    int a[ROW][COL] = {{1,2,3,4},{5,6,7,8},{9,10,11,12}};

    printf("原数组为：\n");
    for(int i=0; i<ROW; i++)
    {
        for(int j=0; j<COL; j++)
        {
            printf("%4d",a[i][j]);
        }
        printf("\n");
    }

    transpose(a);

    printf("转置后的数组为：\n");
    for(int i=0; i<COL; i++)
    {
        for(int j=0; j<ROW; j++)
        {
            printf("%4d",a[j][i]);
        }
        printf("\n");
    }

    return 0;
}

上面的代码中，transpose函数用指向含有COL个元素的一维数组的指针作为形参，因为在C语言中，二维数组在内存中是以一维数组的形式存放的。在函数中，我们通过指针的方式访问二维数组中的每个元素，并交换它们的值。具体来说，我们通过指针p来访问二维数组中的元素，如``*((p+i*COL)+j)``即为二维数组中第i行第j列的元素。通过交换``*((p+i*COL)+j)``和``*((p+j*COL)+i)``的值，即可实现转置。

在主函数中，我们先输出原二维数组a的值，然后调用transpose函数来实现转置，并再次输出转置后的数组。由于是用指针操作数组元素的，因此转置后的数组在内存中的存储方式已经发生了变化，因此在输出时，我们需要将行列顺序互换。

C语言用指针实现4*4二维数组的转置

可以使用以下代码实现：

#include <stdio.h>

void transpose(int *matrix, int row, int col) {
    int temp;
    for (int i = 0; i < row; i++) {
        for (int j = i + 1; j < col; j++) {
            temp = *(matrix + i * col + j);
            *(matrix + i * col + j) = *(matrix + j * col + i);
            *(matrix + j * col + i) = temp;
        }
    }
}

int main() {
    int matrix[4][4] = {{1, 2, 3, 4},
                        {5, 6, 7, 8},
                        {9, 10, 11, 12},
                        {13, 14, 15, 16}};
    printf("Original matrix:\n");
    for (int i = 0; i < 4; i++) {
        for (int j = 0; j < 4; j++) {
            printf("%d ", matrix[i][j]);
        }
        printf("\n");
    }
    transpose((int *)matrix, 4, 4);
    printf("Transposed matrix:\n");
    for (int i = 0; i < 4; i++) {
        for (int j = 0; j < 4; j++) {
            printf("%d ", matrix[i][j]);
        }
        printf("\n");
    }
    return 0;
}

在函数中，我们使用两重循环遍历矩阵的上三角元素，将对应位置的元素交换，即可完成矩阵的转置。

在主函数中，我们先输出原始矩阵，然后调用 `transpose` 函数进行转置操作，最后输出转置后的矩阵。需要注意的是，我们需要将二维数组转换为一维数组进行处理，因为在 C 语言中，多维数组在内存中是连续存储的。