go 递归调用

基本介结

一个函数在函数体内又调用了本身
案例1：

func test(n int) {
    if n > 2 {
        n--
        test(n)
    }
    fmt.Println("n=", n)
}
func main() {
    //调用
    test(4)
}

//分析  
//test(2)  n=2
//test(3)  n=3,2
//test(4)  n=4,3

//n=2
//n=2
//n=3

分析

案例2

func test(n int) {
    if n > 2 {
        n--
        test(3)
    } else {
        fmt.Println("n=", n)
    }

}
func main() {
    //调用
    test(4)
}

//分析
//test(2)  n=2
//test(3)  n=3,2
//test(4)  n=4,3

//结果
//n=2

图例分析

函数递归要遵守的重要原则：

1、执行一个函数时，就创建一个新的受保护的独立空间（新函数栈）
2、函数的局部变量是独立的，不会相互影响
3、递归必须向退出递归的条件逼近，否则就是无限递归。
4、当一个函数执行完毕，或者遇到return，就会返回，遵守谁调用，返回给谁，同时当函数执行完毕或者返回时，该函数本身也会被系统销毁

练习
1、请使用递归的方式，求出斐波那契数1，1，2，3，5，8，13...（前两个数的和等于第三个数）。给你一个整数n，求出它的斐波那契数是多少

package main

import (
    "fmt"
)

//请使用`递归`的方式，求出斐波那契数` 1，1，2，3，5，8，13...`（前两个数的和等于第三个数）。
//给你一个整数`n`，求出它的`斐波那契数`是多少
func feibo(n int) int {
    if n == 1 || n == 2 {
        return 1
    } else {
        return feibo(n-1) + feibo(n-2)
    }
}

func main() {
    //调用
    res := feibo(5)
    fmt.Println("res=", res)
    fmt.Println("res=", feibo(34))
    fmt.Println("res=", feibo(35))
}

2、已经f(1)=3;f(n)=2*f(n-1)+1，求出f(n)的值

package main

import (
    "fmt"
)

func f(n int) int {
    if n == 1 {
        return 3
    } else {
        return 2*f(n-1) + 1
    }
}

func main() {
    //调用
    fmt.Println("f(5)=", f(5))
}
//分析
//f(1) n=2  --> 3  == 2*3 +1 ==7
//f2 n=2 -->2*7 +1 = 15
//f3 n=3 --> 2*15 +1 = 31
//f4  n = 4  --> 2*31 + 1 = 63
//f5  n = 5

//结果是 f(5) = 63

递归技巧：不断的调用，直到触发到临界条件有值为止。

2、有一只猴子摘了一堆桃子，当即吃了一半，可是桃子太好吃了，它又多吃了一个，第二天它把第一天剩下的桃子吃了一半，又多吃了一 个，
就这样到第十天早上它只剩下一个桃子了，问它一共摘了多少个桃子？

// day范围在 1-10之间
func peach(day int) int {
    if day < 1 || day > 10 {
        fmt.Println("日期范围不正确")
    }
    if day == 10 {
        return 1
    } else {
        day++
        return (peach(day) + 1) * 2
    }
}

func main() {
    //调用
    fmt.Println("第一天的桃子的总数是：", peach(1))
}

关于递归的概念，我们都不陌生。简单的来说递归就是一个函数直接或间接地调用自身，是为直接或间接递归。一般来说，递归需要有边界条件、递归前进段和递归返回段。当边界条件不满足时，递归前进；当边界条件满足时，递归返回。