Golang程序寻找矩阵转置的

1年前 ⋅ 0

寻找矩阵转置的Golang程序

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

方法1：使用For Loop查找矩阵的移位

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

算法

第1步 – 导入fmt包。

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

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

第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：使用范围函数查找矩阵的转置

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

算法

第1步 – 导入fmt包。

第2步 – 创建一个函数来查找给定矩阵的转置，称为transpose()。

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

第4步 – 一旦所有的迭代完成，返回结果。

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

第6步 – 调用transpose()函数，将矩阵作为参数传给该函数，并存储结果

第7步 – 使用fmt.Println()函数将得到的最终结果打印在屏幕上。

示例

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循环，而在第二个例子中，我们在一个用户定义的函数中传递矩阵以实现其转置。