Golang 找出矩阵的转置

在这篇文章中，我们将编写一个Go语言程序来找出矩阵的转置。矩阵是按行和列排列的数字集合，是一个二维数组。矩阵的转置定义为通过交换矩阵的行和列得到的矩阵。

方法1：使用For循环找出矩阵的转置

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

步骤

第1步 - 导入fmt包。

第2步 - 调用main()函数。

第3步 - 初始化一个名为matrixA和matrixB的二维数组，并在其中存储元素。

第4步 - 在屏幕上打印矩阵。

第5步 - 为了找到这些矩阵的转置，使用for循环迭代矩阵，并通过将矩阵的每行更改为列来创建一个新的矩阵。

第6步 - 一旦我们遍历了矩阵，就在屏幕上打印所形成的新矩阵。

第7步 - 重复这个过程，找出第二个矩阵的转置，并使用fmt.Println()函数在屏幕上打印转置结果。

示例

使用for循环找到矩阵的转置的Golang程序。

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

方法2：使用 Range 函数找到矩阵的转置

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

步骤

步骤1 - 导入 fmt 包。

步骤2 - 创建一个名为 transpose() 的函数，用于找到给定矩阵的转置。

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

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

步骤5 - 现在，开始 main() 函数。初始化一个整数类型的矩阵并将值存储在其中。然后，在屏幕上打印这些矩阵。

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

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

示例

使用 range 函数找到矩阵的转置的 Golang 程序。

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

结论

我们成功编译并执行了一个用于查找矩阵转置的golang程序，并提供了示例。我们在此使用了两个示例。在第一个示例中，我们在main()函数中使用了for循环，而在第二个示例中，我们将矩阵传递给一个用户定义的函数，以实现其转置。