golang递归算法实现

 递归实现

//递归算法，计算前面两个数的和
func fibonacci(front int) (back int) {
	if front <= 2 {
		back = 1
	} else {
		back = fibonacci(front-1) + fibonacci(front-2) //计算前面两个数的和并返回给back
	}
	return
}

递归调用

for i := 1; i <= 10; i++ {
	result := fibonacci(i)
	fmt.Println(result)

}

完整源码:

package main //包名
//导入模块
import (
	"fmt"     //格式化输出
	"reflect" //反射库

	//随机库
	"time" //时间日期库
)

//接口定义
type Animal interface {
	Speak() string //定义一个方法Speak返回类型是字符串
}

//定义Dog结构
type Dog struct {
}

//定义Cat结构
type Cat struct {
}

//在结构Dog中实现接口方法
func (d Dog) Speak() string {
	return "Dog Speak"
}

//在结构Cat中实现接口方法
func (c Cat) Speak() string {
	return "Cat Speak"
}

//定义一个方法，传入参数是interface{}的集合
func PrintAll(v []interface{}) {
	//遍历对象
	for _, r := range v {
		fmt.Println(r) //输出值
	}
}

//反射测试
func CallAll(v []interface{}) {
	for _, r := range v {
		fmt.Println(reflect.TypeOf(r))
		fmt.Println(reflect.TypeOf(r).Kind())
	}
}

//协程生产消息
//prefix : 产生的字符串前缀
//ch 	 : 通道
func producer_msg(prefix string, ch chan<- string) { //支持字符串格式通信的通道chan  chan<-向通道写数据
	//循环产生消息
	for {
		ch <- fmt.Sprintf("协程生产消息: %s %v", prefix, ch) //将产生的消息写入通道
		time.Sleep(time.Second)                        //等待1秒
	}
}

//协程消费消息
func customer_msg(ch <-chan string) { //支持字符串格式通信的通道ch  <-chan 读取通道数据
	//循环消费消息
	for {
		msg := <-ch                   //读取通道数据并保存到msg
		fmt.Println("协程消费消息: " + msg) //输出数据
	}
}

//递归算法，计算前面两个数的和
func fibonacci(front int) (back int) {
	if front <= 2 {
		back = 1
	} else {
		back = fibonacci(front-1) + fibonacci(front-2) //计算前面两个数的和并返回给back
	}
	return
}

//入口
func main() {
	for i := 1; i <= 10; i++ {
		result := fibonacci(i)
		fmt.Println(result)

	}
	fmt.Println("hi,go")
	animals := []Animal{Dog{}, Cat{}} //初始化集合
	//遍历集合
	for _, ani := range animals {
		v := ani.Speak() //调用接口方法
		fmt.Println(v)   //输出结果
	}

	//根据字符串数据生成[]interface{}
	names := []string{"stanley", "david", "oscar"}
	//生成指定长度的空接口对象集合
	vals := make([]interface{}, len(names))
	//遍历
	for i, v := range names {
		vals[i] = v //赋值
	}

	//调用自定义函数
	PrintAll(vals) //传入[]interface{}对象

	//转换Dog和Cat结构为interface{}
	anis := make([]interface{}, len(animals))
	//anis[0] = animals[0].Speak()
	//anis[1] = animals[1].Speak()
	//遍历集合并给interface{}赋值
	for k, v := range animals {
		anis[k] = "convert to interface{} : " + v.Speak()
		out_kind_type := fmt.Sprintf("Speak: 类型-> %v 种类-> %v", reflect.TypeOf(v.Speak), reflect.TypeOf(v.Speak).Kind())
		fmt.Println(out_kind_type)
	}
	//调用自定义函数输出
	PrintAll(anis) //

	for k, v := range animals {
		anis[k] = v

	}

	CallAll(anis) //

	fmt.Println("class name: " + reflect.TypeOf(Cat{}).Name())

	ch := make(chan string)    //创建数据通道
	go producer_msg("cat", ch) //启动一个协程生产cat数据
	go producer_msg("dog", ch) //启动一个协程生产dog数据

	//消费上面两个协程产生的数据
	customer_msg(ch)
}