使用多维数组与矩阵相乘的Golang程序

在本教程中，我们将编写一个go语言程序，将两个矩阵相乘。单维数组和多维数组的区别在于，前者持有一个属性，而后者则持有另一个数组的索引。此外，多维数组的每个元素都会有相同的数据类型。

方法1：在主函数中使用多维数组将两个矩阵相乘

在这个方法中，我们将编写一个golang程序，在main()函数中使用for循环来乘以两个多维矩阵。

算法

第1步 – 导入fmt包。

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

第3步 – 为使矩阵相乘，使用三个for循环。在矩阵的每次迭代中，通过将两个矩阵的行与列相乘和相加来更新总变量。

第4步 – 在更新总数变量后，将结果存储在结果变量的相应位置，将总数重新初始化为零，并重复这一过程。

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

示例

Golang程序使用多维数组将两个矩阵相乘。

package main
import "fmt"
func main() {

   // initializing variables
   var result [3][2]int
   var i, j, k, total int
   total = 0
   matrixA := [3][3]int{
      {0, 1, 2},
      {4, 5, 6},
      {8, 9, 10},
   }
   matrixB := [3][2]int{
      {10, 11},
      {13, 14},
      {16, 17},
   }

   // printing matrices on the screen
   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()
   }

   // printing a new line
   fmt.Println()
   fmt.Println("The second matrix is:")
   for i = 0; i < 3; i++ {
      for j = 0; j < 2; j++ {
         fmt.Print(matrixB[i][j], "\t")
      }
      fmt.Println()
   }
   fmt.Println()

   // multiplying matrices and storing result
   for i = 0; i < 3; i++ {
      for j = 0; j < 2; j++ {
         for k = 0; k < 3; k++ {
            total = total + matrixA[i][k]*matrixB[k][j]
         }
         result[i][j] = total
         total = 0
      }
   }

   // printing result on the screen
   fmt.Println("Results of matrix multiplication: ")
   for i = 0; i < 3; i++ {
      for j = 0; j < 2; j++ {
         fmt.Print(result[i][j], "\t")
      }
      fmt.Println()
   }
   fmt.Println()
}

输出

The first matrix is:
0  1  2
4  5  6
8  9 10
The second matrix is:
10  11
13  14
16  17
Results of matrix multiplication:
45    48
201  216
357  384

方法2：在外部函数中使用多维数组将两个矩阵相乘

在这个方法中，我们将创建一个用户定义的函数来执行两个矩阵的乘法过程。我们创建的函数将把各自的矩阵作为参数，在执行乘法后，它将返回最终的矩阵，我们可以接收并打印出来。

算法

第1步 – 导入fmt包。

第2步 – 创建一个将给定矩阵相乘的函数，名为MultiplyMatrix()。这个函数接受两个矩阵作为参数，并返回最终的矩阵作为结果。

第3步 – 这个函数使用三个for循环来实现这个逻辑。在矩阵的每一次迭代中，我们通过将两个矩阵的行与列相乘和相加来更新总变量。

第4步 – 在更新总数变量后，将结果存储在结果变量的相应位置，重新启动总数为零并重复这一过程。

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

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

第7步 – 调用MultiplyMatrix()函数，将两个矩阵作为参数传给该函数，并存储结果。

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

示例

Golang程序通过外部函数使用多维数组将两个矩阵相乘

package main
import (
   "fmt"
)

// creating a function to multiply matrices
func MultiplyMatrix(matrixA [3][3]int, matrixB [3][2]int) [3][2]int {
   var total int = 0
   var result [3][2]int

   // multiplying matrices and storing result
   for i := 0; i < 3; i++ {
      for j := 0; j < 2; j++ {
         for k := 0; k < 3; k++ {
            total = total + matrixA[i][k]*matrixB[k][j]
         }
         result[i][j] = total
         total = 0
      }
   }
   return result
}
func main() {

   // initializing variables
   var result [3][2]int
   var i, j int
   matrixA := [3][3]int{
      {0, 1, 2},
      {4, 5, 6},
      {8, 9, 10},
   }
   matrixB := [3][2]int{
      {10, 11},
      {13, 14},
      {16, 17},
   }

   // printing matrices on the screen
   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()
   }

   // printing a new line
   fmt.Println()
   fmt.Println("The second matrix is:")
   for i = 0; i < 3; i++ {
      for j = 0; j < 2; j++ {
         fmt.Print(matrixB[i][j], "\t")
      }
      fmt.Println()
   }
   fmt.Println()
   result = MultiplyMatrix(matrixA, matrixB)
   fmt.Println("The results of multiplication of matrix A & B: ")
   for i := 0; i < 3; i++ {
      for j := 0; j < 2; j++ {
         fmt.Print(result[i][j], "\t")
      }
      fmt.Println()
   }
}

输出

The first matrix is:
0  1  2
4  5  6
8  9 10
The second matrix is:
10  11
13  14
16  17
The results of multiplication of matrix A & B:
45   48
201  216
357  384