go 递归

递归实现n以内数的和

//递归实现求和
func sumRecursion(n int) int{
	//定义递归返回条件
	if n <= 0{
		return 0
	}
	if n == 1{
		return 1
	}
	return n + sumRecursion(n-1)
}

递归实现斐波那契数列

func main() {
        //输出10个斐波那契数列
	for i:=1;i<=10; i++{
		fmt.Println(Fibonacci(i))
	}
}

//实现斐波那契数列的函数
func Fibonacci(n int) int{
	if n <= 2{
		return 1
	}
	return Fibonacci(n-1) + Fibonacci(n-2)
}

递归实现文件目录下的所有文件

//递归实现遍历目录下的所有文件
func CatalogRecursion(path string){
		//返回FileInfo, error
		fi, err := os.Stat(path)
		//判断文件路径是否存在
		if err != nil{
			fmt.Printf("%s不存在", path)
		}
		//递归返回条件
		//判断是否是文件
		if fi.Mode().IsRegular(){
			fmt.Printf("文件是%s\n", path)
		}
		//递归条件
		//判断是否是目录
		if fi.Mode().IsDir(){
			//返回切片 []FileIo, error
			filos,_ := ioutil.ReadDir(path)
			for _, filo := range filos{
				//获取文件名称
				name := filo.Name()
				subPath := path + "/" + name
				//fmt.Printf("%s下的文件或目录是%s\n", path, subPath)
				//递归
				CatalogRecursion(subPath)
			}

		}
	}

递归性能

//for循环实现求和
func SumFor(n int) int {
	sum := 0
	for i:=0;i<=n;i++{
		sum += i
	}
	return sum
}

func main() {
	starTime := time.Now()
       //调用递归求和
	fmt.Println(sumRecursion(100000))
	endTime := time.Now()
	fmt.Println(endTime.Sub(starTime))

	starTime2 := time.Now()
       //调用for循环求和
	fmt.Println(SumFor(100000))
	endTime2 := time.Now()
	fmt.Println(endTime2.Sub(starTime2))
}

输出结果：

5000050000
14.0271ms
5000050000
0s

1.从结果可以看出，递归执行的时间长，没有for循环执行的快；

2.递归执行大量运算时也会抛出栈溢出，因为递归时需要不断向栈中添加变量名:

比如：sumRecursion(10) = 10 + sumRecursion(9);   
      sumRecursion(9) = 9 + sumRecursion(8);                     
      sumRecursion(8) = 8 + sumRecursion(7)