Golang 使用递归计算幂

在本教程中，我们将学习如何使用递归技术在Go编程语言中计算幂数。

幂可以定义为一个数字乘以自身特定次数。

指数可以定义为一个数字在乘法中使用的次数。在数学中，幂和指数是重要的工具，可以用来重写长乘法问题，尤其是在代数中。

示例：24 = 2 × 2 × 2 × 2 = 16，其中2是底数，4是指数。

递归是指一个函数通过直接或间接的方式调用自己。每个递归函数都有一个基本情况或基本条件，它是递归中最后一个可执行的语句，并停止进一步的调用。

以下我们展示了两种不同类型的递归方法的示例。

示例1：使用直接递归方法计算幂的Golang程序代码

语法

Result = (num * POWER(num, power-1)
// Recursive function call to the function POWER() by itself up to the defined condition

步骤

• 步骤1 − 导入fmt包。

• 步骤2 − 创建POWER()函数。

• 步骤3 − 使用if条件语句。

• 步骤4 − 对函数自身进行递归调用。

• 步骤5 − 开始main()函数。

• 步骤6 − 声明并初始化变量。

• 步骤7 − 调用POWER()函数。

• 步骤8 − 使用fmt.Printf()将结果打印到屏幕上。

示例

// GOLANG PROGRAM TO CALCULATE THE POWER USING RECURSION
// Direct Recursion example
package main

// fmt package provides the function to print anything
import "fmt"

// create a function
func POWER(num int, power int) int {
   var result int = 1
   if power != 0 {

      // Recursive function call to itself
      result = (num * POWER(num, power-1))
   }
   return result
}
func main() {
   fmt.Println("Golang Program to calculate the power using recursion")
   // declare and initialize the integer variables
   var base int = 4
   var power int = 2
   var result int

   // calling the POWER() function
   result = POWER(base, power)

   // Print the result using in-built function fmt.Printf()
   fmt.Printf("%d to the power of %d is: %d\n", base, power, result)
}

输出

Golang Program to calculate the power using recursion
4 to the power of 2 is: 16

代码描述

• 在以上程序中，我们首先声明了主要包。

• 我们导入了包含fmt包文件的fmt包。

• 接下来，我们创建一个名为POWER()的函数，使用直接递归技术计算幂次。

• 我们将使用if条件语句，如果指定的条件为真，则执行一块代码，然后对函数本身进行递归调用。

• 现在开始函数main()。GO程序的执行从main()函数开始。声明整数变量base、power和result。

• 现在调用POWER()函数。

• 最后，使用内置函数fmt.Printf()将结果打印到屏幕上。此函数在fmt包下定义，它帮助写入标准输出。

示例2：使用间接递归方法计算幂次的Golang程序代码

语法

func recursion_1() {
   recursion_2()}
func recursion_2(){
   recursion_1()}
func main() {
   recursion_1();
}

步骤

• 步骤1 - 导入包 fmt 。

• 步骤2 - 创建函数 POWER_1() 。

• 步骤3 - 使用if条件语句。

• 步骤4 - 递归调用函数 POWER_2() 。

• 步骤5 - 创建函数 POWER_2() 。

• 步骤6 - 间接递归调用函数 POWER_1() 。

• 步骤7 - 启动函数 main() 。

• 步骤8 - 声明并初始化变量。

• 步骤9 - 调用函数 POWER_2() 。

• 步骤10 - 使用 fmt.Printf() 在屏幕上打印结果。

示例

// GOLANG PROGRAM TO CALCULATE THE POWER USING RECURSION
// Indirect Recursion example
package main

// fmt package provides the function to print anything
import "fmt"

// create a first Recursive function
func POWER_1(num int, power int) int {
   var result int = 1
   if power != 0 {

      // Recursive function call to the second function
      result = (num * POWER_2(num, power-1))
   }
   return result
}
// create a second Recursive function
func POWER_2(num int, power int) int {
   var result int = 1
   if power != 0 {

      // Recursive function call to the first function
      // which calls this first function indirectly
      result = (num * POWER_1(num, power-1))
   }
   return result
}
func main() {
   fmt.Println("Golang Program to calculate the power using recursion")
   // declare and initialize the integer variables
   var base int = 5
   var power int = 2
   var result int

   // calling the POWER_2() function
   result = POWER_2(base, power)

   // Print the result using in-built function fmt.Printf()
   fmt.Printf("%d to the power of %d is: %d\n", base, power, result)
}

输出

Golang Program to calculate the power using recursion
5 to the power of 2 is: 25

代码说明

• 在上面的程序中，我们首先声明了main包。

• 我们导入了包含fmt包文件的fmt包。

• 接下来，我们创建了一个函数POWER_1()，使用间接递归技术计算幂次。

• 我们将使用if条件语句，如果指定条件为真，则执行一段代码块，然后递归调用第二个函数POWER_2()。

• 接下来，我们创建一个函数POWER_2()。在这个函数中，递归调用第一个函数POWER_1()，间接地调用第一个函数。

• 现在开始函数main()。GO程序从函数main()开始执行。

• 声明整数变量base，power和result。

• 现在调用函数POWER_2()。

• 最后，使用内置函数fmt.Printf()将结果打印到屏幕上。该函数在fmt包下定义，用于写入标准输出。

结论

在上面的两个示例中，我们成功编译和执行了使用递归技术计算幂的Golang程序代码。在第一个示例中，我们展示了直接递归方法，而在第二个示例中，我们展示了间接递归方法。