c语言输入一个n×n的方阵，把其转置并输出。 输入格式: 测试数据有多组，处理到文件尾。对于每组测试，第一行输入一个整数n（n≤10），接下来的n行每行输入n个不超过2位的整数。 输出格式: 对于每组测试，输出这n×n矩阵的转置方阵，每行的每两个数据之间留一个空格。

以下是C语言的代码实现：

#include <stdio.h>

int main() {
    int n, i, j;
    while (scanf("%d", &n) != EOF) { // 处理多组测试数据
        int matrix[n][n]; // 定义n×n的数组
        for (i = 0; i < n; i++) {
            for (j = 0; j < n; j++) {
                scanf("%d", &matrix[i][j]); // 输入矩阵元素
            }
        }
        for (i = 0; i < n; i++) {
            for (j = 0; j < n; j++) {
                printf("%d ", matrix[j][i]); // 输出转置后的矩阵
            }
            printf("\n"); // 换行
        }
    }
    return 0;
}

输入样例：

3
1 2 3
4 5 6
7 8 9

输出样例：

1 4 7 
2 5 8 
3 6 9 

相关问题

输入一个n×n的方阵，把其转置并输出

### 回答1：
将一个n×n的方阵进行转置，就是将其行和列对调，得到一个新的n×n的方阵。具体操作可以通过交换矩阵中对应位置的元素来实现。以下是一个示例代码：

n = int(input("请输入方阵的大小："))
matrix = []
for i in range(n):
    row = list(map(int, input().split()))
    matrix.append(row)

# 转置矩阵
transpose = []
for i in range(n):
    row = []
    for j in range(n):
        row.append(matrix[j][i])
    transpose.append(row)

# 输出转置后的矩阵
for i in range(n):
    for j in range(n):
        print(transpose[i][j], end=" ")
    print()

输入示例：

请输入方阵的大小：3
1 2 3
4 5 6
7 8 9

输出示例：

1 4 7 
2 5 8 
3 6 9 

### 回答2：
方阵是一种特殊的矩阵，它的行数和列数相等。要将一个 n×n 的方阵转置，就是将矩阵的行和列互换，即将矩阵横向看成纵向，纵向看成横向。下面介绍一种简单的方法来实现方阵的转置，并输出转置后的方阵。

首先，将输入的方阵存储到一个二维数组中，然后通过两层嵌套的循环来遍历这个矩阵。外层循环遍历行，内层循环遍历列。在循环遍历的时候，将原始矩阵的行和列互换，即将 matrix[i][j] 放到新矩阵的 matrix[j][i] 的位置上。这样就实现了方阵的转置。

接下来，将转置后的方阵输出。同样是采用双重循环，逐行逐列输出即可。代码如下：

#include <iostream>
using namespace std;

const int N = 1010;

int matrix[N][N], new_matrix[N][N];

int main()
{
    int n;
    cin >> n;
    for(int i = 0; i < n; i++)
        for(int j = 0; j < n; j++)
            cin >> matrix[i][j];
    for(int i = 0; i < n; i++)
        for(int j = 0; j < n; j++)
            new_matrix[j][i] = matrix[i][j];
    for(int i = 0; i < n; i++)
    {
        for(int j = 0; j < n; j++)
            cout << new_matrix[i][j] << " ";
        cout << endl;
    }
    return 0;
}

通过上述程序，输入一个n×n的方阵，程序将其转置，并输出转置后的方阵。这个程序的时间复杂度为 O(n^2)，空间复杂度为 O(n^2)，是一种比较简单和常用的方法。

### 回答3：
方阵是指行和列相同的矩阵。将一个n×n的方阵进行转置，就是将其按对角线翻转得到一个新的方阵。具体地，就是将原来第i列的元素变成新方阵第i行的元素，依次操作即可。下面给出一个具体的例子：

输入一个3×3的方阵
1 2 3
4 5 6
7 8 9

将其转置后，得到一个新的3×3的方阵

1 4 7
2 5 8
3 6 9

代码实现：

int a[1000][1000];
int b[1000][1000];
int n;
for(int i=0;i<n;i++){
for(int j=0;j<n;j++){
cin>>a[i][j];
}
}
for(int i=0;i<n;i++){
for(int j=0;j<n;j++){
b[j][i]=a[i][j];
}
}
for(int i=0;i<n;i++){
for(int j=0;j<n;j++){
cout<<b[i][j]<<" ";
}
cout<<endl;
}

其中，a[i][j]表示原方阵的第i行第j列元素，b[j][i]表示新方阵的第j行第i列元素，最终输出新方阵即可。

输入一个n×n的方阵，把其转置并输出。

### 回答1：
将一个n×n的方阵转置后输出，可以通过以下步骤实现：

1. 遍历方阵的每一个元素，将其行列互换，即将第i行第j列的元素与第j行第i列的元素交换。

2. 输出转置后的方阵。

代码示例：

n = int(input())  # 输入方阵的大小
matrix = []  # 定义一个空的方阵

# 读入方阵的每一行
for i in range(n):
    row = list(map(int, input().split()))
    matrix.append(row)

# 转置方阵
for i in range(n):
    for j in range(i, n):
        matrix[i][j], matrix[j][i] = matrix[j][i], matrix[i][j]

# 输出转置后的方阵
for i in range(n):
    for j in range(n):
        print(matrix[i][j], end=' ')
    print()

输入示例：

3
1 2 3
4 5 6
7 8 9

输出示例：

1 4 7 
2 5 8 
3 6 9 

### 回答2：
方阵是一个具有相同行和列数的矩阵，输入一个n×n的方阵就是输入一个n行n列的矩阵。要求将该矩阵进行转置，即行变成列，列变成行，然后输出转置后的矩阵。

转置矩阵的方法是将原矩阵的行和列对调。具体来说，对于一个矩阵A，其转置矩阵AT的第i行第j列元素应该是A的第j行第i列元素。这个过程可以用两个嵌套的for循环实现。

具体代码如下：

n = int(input("请输入矩阵的大小："))
matrix = []
for i in range(n):
    row = input("请输入第%d行矩阵元素，以空格分隔：" % (i+1))
    matrix.append(row.split())

transpose = []
for i in range(n):
    row = []
    for j in range(n):
        row.append(matrix[j][i])
    transpose.append(row)

print("转置矩阵为：")
for i in transpose:
    for j in i:
        print(j, end=' ')
    print()

这个代码先将原矩阵输入到一个二维列表中，然后创建一个新的二维列表来存放转置矩阵。两个for循环遍历原矩阵的所有元素，并将其转置后放到新矩阵中。最后，用两个for循环输出新矩阵的所有元素即可。

### 回答3：
方阵是一种在数学中应用广泛的矩阵，其中每一行和每一列的元素数量相等，即有n行n列。对于一个n×n的方阵，我们可以通过转置矩阵的方式来交换矩阵的行和列，即把原矩阵的行变成列，把列变成行，从而得到一新矩阵。

可以用二维数组表示一个n×n的方阵，即使用两个下标i和j来表示矩阵中的元素a_ij。定义一个n×n的方阵A，其转置矩阵为矩阵AT，转置矩阵AT的行和列分别与方阵A的列和行对应。

实现矩阵转置的方法很简单，只需要将方阵A中的每个元素a_ij赋值给转置矩阵AT的对应位置，即AT[j][i] = A[i][j]，就可以得到方阵A的转置矩阵AT。

具体步骤如下：

1. 创建一个n×n的方阵A，并输入其元素值；
2. 创建一个n×n的方阵AT，将其所有元素置为0；
3. 使用双重循环，遍历矩阵A的每个元素a_ij，将其赋值给对应位置的AT[j][i]，即AT[j][i] = A[i][j]；
4. 遍历输出转置矩阵AT的元素。

下面是用Python实现的代码：

n = int(input("请输入矩阵的行数与列数："))
A = [[0 for i in range(n)] for j in range(n)]
AT = [[0 for i in range(n)] for j in range(n)]

print("请输入矩阵的元素值：")
for i in range(n):
for j in range(n):
A[i][j] = int(input())

print("原矩阵为：")
for i in range(n):
for j in range(n):
print(A[i][j], end=" ")
print()

for i in range(n):
for j in range(n):
AT[j][i] = A[i][j]

print("转置矩阵为：")
for i in range(n):
for j in range(n):
print(AT[i][j], end=" ")
print()

通过这个简单的例子可以看出，矩阵转置是一个比较常见的矩阵操作，可以用于解决很多问题。除了用Python实现，还可以用其他编程语言实现，例如C++、Java等，在不同的应用场景中发挥作用。