Go语言程序：求矩阵的转置

---

本文将编写一个 Go 语言程序来查找矩阵的转置。矩阵是由按行和列排列的数字集合组成的二维数组。矩阵的转置定义为通过交换该矩阵的行和列获得的矩阵。

方法一：使用 For 循环查找矩阵的转置

在这个例子中，我们将编写一个 Go 语言程序，使用主函数中的for循环来查找矩阵的转置。

算法

步骤 1 − 导入 fmt 包。

步骤 2 − 调用 main() 函数。

步骤 3 − 初始化名为 matrixA 和 matrixB 的二维数组，并向其中存储元素。

步骤 4 − 在屏幕上打印矩阵。

步骤 5 − 要查找这些矩阵的转置，请使用 for 循环迭代矩阵，并通过将矩阵的每一行更改为列来创建一个新矩阵。

步骤 6 − 迭代完矩阵后。在屏幕上打印新生成的矩阵。

步骤 7 − 对第二个矩阵重复此过程，并使用 fmt.Println() 函数在屏幕上打印转置。

示例

使用 for 循环查找矩阵转置的 Go 语言程序

package main
import (
   "fmt"
)
func main() {
   var i, j int
   var transposeMat [3][3]int
   matrixA := [3][3]int{
      {0, 1, 2},
      {4, 5, 6},
      {8, 9, 10},
   }
   matrixB := [3][3]int{
      {10, 11, 12},
      {14, 15, 16},
      {18, 19, 10},
   }
   fmt.Println("The first matrix is:")
   for i = 0; i < 3; i++ {
      for j = 0; j < 3; j++ {
         fmt.Print(matrixA[i][j], "\t")
      }
      fmt.Println()
   }
   fmt.Println()
   for i = 0; i < 3; i++ {
      for j = 0; j < 3; j++ {
         transposeMat[j][i] = matrixA[i][j]
      }
   }
   fmt.Println("The transpose of matrix is:")
   for i = 0; i < 3; i++ {
      for j = 0; j < 3; j++ {
         fmt.Print(transposeMat[i][j], "\t")
      }
      fmt.Println()
   }
   fmt.Println()
   fmt.Println("The second matrix is:")
   for i = 0; i < 3; i++ {
      for j = 0; j < 3; j++ {
         fmt.Print(matrixB[i][j], "\t")
      }
      fmt.Println()
   }
   for i = 0; i < 3; i++ {
      for j = 0; j < 3; j++ {
         transposeMat[j][i] = matrixB[i][j]
      }
   }
   fmt.Println()
   fmt.Println("The transpose of matrix is:")
   for i = 0; i < 3; i++ {
      for j = 0; j < 3; j++ {
         fmt.Print(transposeMat[i][j], "\t")
      }
      fmt.Println()
   }
}

输出

The first matrix is:
0  1  2
4  5  6
8 9  10
The transpose of matrix is:
0  4  8
1  5  9
2  6 10
The second matrix is:
10  11  12
14  15  16
18  19  10
The transpose of matrix is:
10  14  18
11  15  19
12  16  10

方法二：使用 Range 函数查找矩阵的转置

现在让我们来看另一种在 Go 编程语言中查找矩阵转置的方法。在这种方法中，我们将使用用户定义的函数来实现结果。此函数将接受矩阵作为参数，并将结果返回给主程序。

算法

步骤 1 − 导入 fmt 包。

步骤 2 − 创建一个名为 transpose() 的函数来查找给定矩阵的转置。

步骤 3 − 此函数使用两个 for 循环来迭代矩阵。在矩阵的每次迭代中，我们都通过交换接收到的矩阵的行和列来更新新矩阵的元素。

步骤 4 − 完成所有迭代后，返回结果。

步骤 5 − 现在，启动 main() 函数。初始化一个整数类型的矩阵，并向其中存储值。此外，在屏幕上打印这些矩阵。

步骤 6 − 通过将矩阵作为参数传递给函数并将结果存储起来，来调用 transpose() 函数。

步骤 7 − 使用 fmt.Println() 函数在屏幕上打印最终获得的结果。

示例

使用 range 函数查找矩阵转置的 Go 语言程序。

package main
import (
   "fmt"
)

// creating a function to find transpose
func transpose(matrixA [3][3]int) [3][3]int {
   var transposeMat [3][3]int
   for i, rows := range matrixA {
      for j := range rows {
         transposeMat[j][i] = matrixA[i][j]
      }
   }
   return transposeMat
}
func main() {
   var i, j int
   var transposeMat [3][3]int
   matrixA := [3][3]int{
      {0, 1, 2},
      {4, 5, 6},
      {8, 9, 10},
   }
   fmt.Println("The matrix is:")
   for i = 0; i < 3; i++ {
      for j = 0; j < 3; j++ {
         fmt.Print(matrixA[i][j], "\t")
      }
      fmt.Println()
   }
   fmt.Println()

   // calling the transpose function
   transposeMat = transpose(matrixA)
   fmt.Println("The transpose of above matrix is:")
   for i, rows := range matrixA {
      for j := range rows {
         fmt.Print(transposeMat[i][j], "\t")
      }
      fmt.Println()
   }
   fmt.Println()
}

输出

The matrix is:
0  1  2
4  5  6
8  9 10

The transpose of above matrix is:
0  4  8
1  5  9
2  6 10

结论

我们已经成功编译并执行了一个 Go 语言程序来查找矩阵的转置以及示例。我们在这里使用了两个示例。在第一个示例中，我们在 main() 函数中使用了 for 循环，而在第二个示例中，我们将矩阵传递给用户定义的函数来实现其转置。