直观理解（尾）递归函数

前言

咱们都见识了很多关于递归与尾递归的各类长篇概论，本文将经过对下面几个问题的直观体验，来帮助加深对递归的理解。

本文内容目录：

• 什么是调用栈？
• 什么是递归函数？
• 递归的调用栈是怎样？
• 尾递归的调用栈是怎样？
• 为何说尾递归的实如今本质上是跟循环等价？

什么是调用栈？

栈 是一种常见的数据结构，具备后进先出（LIFO）的特色。 调用栈 则是计算机内部对函数调用所分配内存时的一种栈结构。

什么是递归函数？

递归函数 简单的讲，就是函数在内部调用本身。

在编写递归函数的时候，咱们要注意组成它的两个条件，分别是：基线条件 和 递归条件 （也叫回归条件）。

递归函数实际上是利用了分而治之的思想（Divide and Conquer D&C），下面用一个简单的递归函数来讲明。

假设咱们如今须要一个递增函数increasing(n)，其实现为：

def increasing(n = 0):
	print('n = %d' % n)
	increasing(n + 1)
复制代码

咱们很容易发现，这样的代码会永不休止的执行，最后会形成栈溢出，简单的说就是内存满了。由于根本没人告诉它何时该停下来，因此它不断的重复执行，形成无限循环。

假设递增的值到100的时候就再也不执行，则其实现为：

def increasing(n = 0):
	print('n = %d' % n)
	if n == 100: // --> 基线条件
		return
	else: // --> 递归条件
		increasing(n + 1)
复制代码

从上面能够看出，递归条件指的是函数在内部继续调用本身，基线条件指的是函数再也不调用本身的状况。

所谓 Divide and Conquer，分别对应的则是递归条件和基线条件。

递归的调用栈是怎样？

下面咱们经过计算一个数的阶乘的函数进行解释。它将会有三个不一样版本，分别是递归求阶乘，尾递归求阶乘，for循环求阶乘。

由于这里要研究递归的调用栈状况，因此咱们先来看看递归求阶乘的实现：

print('##### 递归求阶乘 #####')
def  fact(n):
	if n == 1:
		return 1
	else:
		return n * fact(n - 1)

print('result = %s' % fact(4))
复制代码

为了更好的解释说明，我将上面的代码略做改动：

print('##### 递归求阶乘 #####')
def  fact(n):
	if n == 1:
		result = 1
		return result
	else:
		print('current: n = %d, result = %d * fact(%d - 1)' % (n, n, n)) 
		result = fact(n - 1) 
		return n * result 
复制代码

改动理由：

1. 调用栈中的函数都保留计算结果变量 result，要特别注意的是调用栈中的各个函数内部的变量对函数彼此而言是互相隔离没法访问的。
2. 在递归条件中打印活跃期的状况。

所谓活跃期，指的是计算机当前所操做的函数执行期。

运行结果为：

##### 递归求阶乘 #####
current: n = 4, result = 4 * fact(4 - 1)
current: n = 3, result = 3 * fact(3 - 1)
current: n = 2, result = 2 * fact(2 - 1)
result = 24
复制代码

其调用栈状况：

正常状况下，栈顶函数执行完毕后将弹出。但咱们却看到递归函数的调用不断的向调用栈压入执行函数，那么问题来了，为何调用栈前面的函数"执行完毕"后不自动弹出呢？

答案是 栈顶函数其实并未执行完成，由于栈顶函数的变量result的值还没有肯定，它还须要 下一个递归函数返回的值（上下文） 来计算，因此一直处于非活跃期状态被保留在调用栈中。

上面的答案还需完善一下，由于当某个栈顶函数，例如fact(1)，在执行到基线条件时，result的值已经肯定下来，而无需等待下一个递归函数的上下文，因此该栈顶函数真正执行完毕，并弹出调用栈。又由于下一个栈顶函数能够拿到已弹栈的函数返回的上下文，于是当弹栈函数交待完成后，也相继弹出调用栈。

尾递归的调用栈是怎样？

咱们先来看看尾递归求阶乘的实现：

print('##### 尾递归求阶乘 #####')
def fact_tail(n):
	return tail_fact_count(n)

def tail_fact_count(n, result = 1):
	if n == 1:
		return result
	else:
		print('current: n = %d, result = %d' % (n, result))
		print('next: n = %d, result = %d' % (n - 1, result * n))
		print('----------------')
		return tail_fact_count(n - 1, n * result)

print('result = %s' % fact_tail(4))
复制代码

一样的，咱们将上述代码略做改动：

print('##### 尾递归求阶乘 #####')
def fact_tail(n):
	result = tail_fact_count(n)
	return result

def tail_fact_count(n, result = 1):
	if n == 1:
		return result
	else:
		print('current: n = %d, result = %d' % (n, result))
		print('next: n = %d, result = %d' % (n - 1, result * n))
		print('----------------')
		result = n * result
		n = n - 1
		return tail_fact_count(n, result)

print('result = %s' % fact_tail(4))
复制代码

运行结果为：

##### 尾递归求阶乘 #####
current: n = 4, result = 1
next: n = 3, result = 4
----------------
current: n = 3, result = 4
next: n = 2, result = 12
----------------
current: n = 2, result = 12
next: n = 1, result = 24
----------------
result = 24
复制代码

咱们再来看看它的调用栈状况：

仔细对比前面递归函数的调用栈状况，咱们能够看出递归与尾递归调用栈的两个明显不一样点：

1. 尾递归的调用栈明显比递归的调用栈清爽不少。
2. 尾递归弹栈顺序是由上至下执行；而递归弹栈顺序是由下至上执行的。（这里的弹栈顺序指的不是物理顺序）

咱们再来看看前面递归函数的实现。在递归实现中，result的值由于须要 下一个递归函数返回的值 来计算才能肯定，因此栈顶函数（设A）一直在调用栈中停留等待下一个栈顶函数（设B）的返回值，一旦下一个栈顶函数（B）返回了确切的result值，那么当B交待完成以后就会弹出，所谓交待便是由于上一个栈顶函数A须要下一个栈顶函数即B的返回值，当A拿到了B的值就是交待完成了。以此类推，递归的弹栈顺序则如图所示由下往上弹出。

那么尾递归究竟作了什么猫腻？

尾递归其实在result的值上作了猫腻。在尾递归的实现中，result的值在当前栈顶函数中已经肯定下来了，并经计算后交待给下一个栈顶函数。因此当栈顶函数完成了它的使命（把result值传递给下一个执行函数），它就会愉快的在调用栈上弹出。

概括来说:

• 递归函数须要将整个函数做为上下文来完成 目的。
• 尾递归则把 目的 在当前函数中完成，并交待给下一个函数。

在本例子中的 目的 指的是肯定result值。

为何说尾递归的实如今本质上是跟循环等价？

按照惯例，先上代码。可是为了更好的理解与尾递归的联系，最好仍是花个十几秒思考一下如何实现for循环求阶乘吧~

为了减小篇幅，直接贴上略做修改的代码：

print('##### for循环求阶乘 #####')
def fact_for(n):
	if n == 1:
		return 1
	else:
		result = 1
		for i in range(n, 0, -1):
			print('current: n = %d, result = %d' % (i, result))
			result = for_fact_count(i, result)
		return result
	
def  for_fact_count(n, result = 1):
	return n * result

print('result = %s' % fact_for(4))

复制代码

运行结果为：

##### for循环求阶乘 #####
current: n = 4, result = 1
current: n = 3, result = 4
current: n = 2, result = 12
current: n = 1, result = 24
result = 24
复制代码

当咱们思考如何使用for循环去实现求阶乘的过程当中，咱们会想到用一个变量去存储计算的值。在上述代码中指的就是 result (= 1)。

为了便于理解for循环与尾递归，我设计了这么一个函数 for_fact_count(n, result = 1)，它接收 当前result值并经计算后刷新result值。

在不影响for循环的实现我已经将其与尾递归的实现作了类似的转化（连名字的都好类似啦），因此请开始你的表演，把for循环求阶乘的调用栈画出来吧~

结语

• 虽然说本文使用了Python进行编码解释，可是目前大多数编程语言都没有针对尾递归作优化，Python解释器也没有，因此即使使用了尾递归进行求阶乘，在运行过程当中仍是会形成栈溢出。而Xcode在debug环境下不会对尾递归作优化，需将其设为release。
• 小生才疏浅陋，文中不免有错漏之处，请多多指教，感谢您的阅读。