Go语言学习（七）练练笔之递归

学了一段时间的Go语言了，今天来见识下Go语言写的递归程序。

先来做个经典题题目：

有一对兔子，从出生后第3个月起每个月都生一对兔子，小兔子长到第三个月后每个月又生一对兔子，假如兔子都不死，问每个月的兔子总数为多少？

分析：

有以下数学表达式：

Y₁=X₂+X₃ ，Y₂=X₁ ，Y₃=X₂+X₃

Z₁=Y₂+Y₃ ，Z₂=Y₁ ，Z₃=Y₂+Y₃

Z₁+Z₂+Z₃= Y₂+Y₃+Y₁+(Y₂+Y₃)=(Y₂+Y₃+Y₁)+(X₂+X₃+X₁)

因此上面每个月的兔子的数量满足斐波那契数列。斐波那契数列，那就easy了~~

package main

import "fmt"

func main() {
	var n float32 = 5
	result1 := fibonacciRecursively(n)
	fmt.Println(result1)
}

//普通递归方式
func fibonacciRecursively(n float32) float32 {
	if n < 3 {
		return 1
	}

	return fibonacciRecursively(n-1) + fibonacciRecursively(n-2)
}

嗯，至此，问题就解决了，不过后来发现，还有一种“尾递归”的做法。　　

下面换用尾递归来实现上面的斐波纳契数列：

package main

import "fmt"

func main() {
    var n float32 = 5

    result2 := fibonacciTailRecursively(5, 1, 1)
    fmt.Println(result2)
}


//尾递归方式
func fibonacciTailRecursively(n float32, acc1 float32, acc2 float32) float32 {
    if n == 1 {
        return acc1
    }

    return fibonacciTailRecursively(n-1, acc2, acc1+acc2)
}

使用尾递归，速度确实快了很多。

————————————————摘自百度百科——————————

尾递归是极其重要的，不用尾递归，函数的堆栈耗用难以估量，需要保存很多中间函数的堆栈。比如f(n, sum) = f(n-1) + value(n) + sum; 会保存n个函数调用堆栈，而使用尾递归f(n, sum) = f(n-1, sum+value(n)); 这样则只保留后一个函数堆栈即可，之前的可优化删去。

尾递归就是从最后开始计算, 每递归一次就算出相应的结果, 也就是说, 函数调用出现在调用者函数的尾部, 因为是尾部, 所以根本没有必要去保存任何局部变量. 直接让被调用的函数返回时越过调用者, 返回到调用者的调用者去.

————————————————摘自百度百科———————————

再来一个阶乘的尾递归实现Go语言版：

package main

import "fmt"

func main() {
    var n float32 = 6
    fmt.Println(factorialRecursively(n))
    fmt.Println(factorialTailRecursively(n,1))
}

//普通递归
func factorialRecursively(n float32) float32 {
    if n == 1 {
        return 1
    }

    return n * factorialRecursively(n-1)
}

//尾递归
func factorialTailRecursively(n float32, acc float32) float32 {
    //0！=1，1！=1，所以这里判断n==0或者n==1都对。
    if n == 0 {
        return acc
    }

    return factorialTailRecursively(n-1, acc*n)
}