【Go】Go 语言教程--Go 语言递归函数（十七）

旧城等待， 2023-10-13 19:29 64阅读 0赞

往期回顾：

*  [Go 语言教程–介绍（一）][Go]
 *  [Go 语言教程–语言结构（二）][Go 1]
 *  [Go 语言教程–语言结构（三）][Go 2]
 *  [Go 语言教程–数据类型（四）][Go 3]
 *  [Go 语言教程–语言变量（五）][Go 4]
 *  [Go 语言教程–GO语言常量（六）][Go _GO]
 *  [Go 语言教程–GO语言运算符（七）][Go _GO 1]
 *  [Go 语言教程–GO条件和循环语句（八）][Go _GO 2]
 *  [Go 语言教程–GO语言函数（九）][Go _GO 3]
 *  [Go 语言教程–GO语言变量作用域（十）][Go _GO 4]
 *  [Go 语言教程–GO语言数组（十一）][Go _GO 5]
 *  [Go 语言教程–GO语言指针（十二）][Go _GO 6]
 *  [Go 语言教程–GO语言结构体（十三）][Go _GO 7]
 *  [Go 语言教程–GO语言切片(Slice)（十四）][Go _GO_Slice]
 *  [Go 语言教程–Go 语言范围(Range)（十五）][Go _Go _Range]
 *  [Go 语言教程–Go 语言Map(集合)（十六）][Go _Go _Map]

#### 文章目录 ####

*  前言
 *  阶乘
 *  斐波那契数列
 *  求平方根

## 前言 ##

递归，就是在运行的过程中调用自己。

语法格式如下：

func recursion() {
        
       recursion() /* 函数调用自身 */
    }
    
    func main() {
        
       recursion()
    }

Go 语言支持递归。但我们在使用递归时，开发者需要设置退出条件，否则递归将陷入无限循环中。

递归函数对于解决数学上的问题是非常有用的，就像计算阶乘，生成斐波那契数列等。

## 阶乘 ##

以下实例通过 Go 语言的递归函数实例阶乘：

实例

package main
    
    import "fmt"
    
    func Factorial(n uint64)(result uint64) {
        
        if (n > 0) {
        
            result = n * Factorial(n-1)
            return result
        }
        return 1
    }
    
    func main() {
          
        var i int = 15
        fmt.Printf("%d 的阶乘是 %d\n", i, Factorial(uint64(i)))
    }

以上实例执行输出结果为：

15 的阶乘是 1307674368000

## 斐波那契数列 ##

以下实例通过 Go 语言的递归函数实现斐波那契数列：

实例

package main
    
    import "fmt"
    
    func fibonacci(n int) int {
        
      if n < 2 {
        
       return n
      }
      return fibonacci(n-2) + fibonacci(n-1)
    }
    
    func main() {
        
        var i int
        for i = 0; i < 10; i++ {
        
           fmt.Printf("%d\t", fibonacci(i))
        }
    }

以上实例执行输出结果为：

0    1    1    2    3    5    8    13    21    34

## 求平方根 ##

以下实例通过 Go 语言使用递归方法实现求平方根的代码：

实例

package main
    
    import (
            "fmt"
    )
    
    func sqrtRecursive(x, guess, prevGuess, epsilon float64) float64 {
        
            if diff := guess*guess - x; diff < epsilon && -diff < epsilon {
        
                    return guess
            }
    
            newGuess := (guess + x/guess) / 2
            if newGuess == prevGuess {
        
                    return guess
            }
    
            return sqrtRecursive(x, newGuess, guess, epsilon)
    }
    
    func sqrt(x float64) float64 {
        
            return sqrtRecursive(x, 1.0, 0.0, 1e-9)
    }
    
    func main() {
        
            x := 25.0
            result := sqrt(x)
            fmt.Printf("%.2f 的平方根为 %.6f\n", x, result)
    }

以上实例中，sqrtRecursive 函数使用递归方式实现平方根的计算。

sqrtRecursive 函数接受四个参数：

*  x 表示待求平方根的数
 *  guess 表示当前猜测的平方根值
 *  prevGuess 表示上一次的猜测值
 *  epsilon 表示精度要求（即接近平方根的程度）

递归的终止条件是当前猜测的平方根与上一次猜测的平方根非常接近，差值小于给定的精度 epsilon。

在 sqrt 函数中，我们调用 sqrtRecursive 来计算平方根，并传入初始值和精度要求，然后在 main 函数中，我们调用 sqrt 函数来求解平方根，并将结果打印出来。

执行以上代码输出结果为：

25.00 的平方根为 5.000000

[Go]: https://blog.csdn.net/u011397981/article/details/131498341
[Go 1]: https://blog.csdn.net/u011397981/article/details/131523907
[Go 2]: https://blog.csdn.net/u011397981/article/details/131523987
[Go 3]: https://blog.csdn.net/u011397981/article/details/131525361
[Go 4]: https://blog.csdn.net/u011397981/article/details/131543946
[Go _GO]: https://blog.csdn.net/u011397981/article/details/131553561
[Go _GO 1]: https://blog.csdn.net/u011397981/article/details/131567591
[Go _GO 2]: https://blog.csdn.net/u011397981/article/details/131590680
[Go _GO 3]: https://blog.csdn.net/u011397981/article/details/131607945
[Go _GO 4]: https://blog.csdn.net/u011397981/article/details/131609123
[Go _GO 5]: https://blog.csdn.net/u011397981/article/details/131649896
[Go _GO 6]: https://writer.blog.csdn.net/article/details/131705852
[Go _GO 7]: https://blog.csdn.net/u011397981/article/details/131725092
[Go _GO_Slice]: https://writer.blog.csdn.net/article/details/131740556
[Go _Go _Range]: https://blog.csdn.net/u011397981/article/details/131740708?spm=1001.2014.3001.5501
[Go _Go _Map]: https://blog.csdn.net/u011397981/article/details/131758199