粗看递归

   第一次写blog，答应朋友Leon，写一篇粗略地介绍“递归（recursion）”的文章。
   递归，一种古老但依旧实用的东东，很多算法用递归方法表示，用递归写的程序也很容易让人理解。
   递归的优美在于使得程序更简洁，同时也更自然。尤其是在处理层次性数据的时候，十分强大。当然，递归的缺点也十分明显--性能问题。在性能这个问题点上， 有一种手段能适当改善递归的性能--尾递归（尾递归的概念将在下文解释）。关于优缺点就此打住，还是很容易理解，我就不婆婆妈妈的罗嗦了，我直接切入正 题。
   
什么是递归？
    在这里我们区分一下几个概念“递归过程”和“递归计算过程”以及相对应的“迭代计算过程”。
“ 递归过程”通常是指某个过程（方法）的定义直接或间接地引用了该过程（方法）本身。在本文中如非特别说明，“递归”这个词泛指一个或某种“递归过程”，而在描述递归型计算过程的时候都会用“递归计算过程”。
下面是一个array求和的递归方法

ruby 代码

1. def sum(arr)  
2.   if arr.empty?  
3.     0  
4.   else  
5.     arr.shift + sum(arr)  
6.   end  
7. end  

这是一个递归，同时也是递归计算过程的递归。来看看sum函数在1..5上的求值过程

ruby 代码

1. [1,2,3,4,5]  
2. 1 + sum([2,3,4,5])  
3. 1 + (2 + sum([3,4,5]))  
4. 1 + (2 + (3 + sum([4,5])))  
5. 1 + (2 + (3 + (4 + sum([5]))))  
6. 1 + (2 + (3 + (4 + (5 + sum[]))))  
7. 1 + (2 + (3 + (4 + (5 + 0))))  
8. 1 + (2 + (3 + (4 + 5)))  
9. 1 + (2 + (3 + 9))  
10. 1 + (2 + 12)  
11. 1+ 14  
12. 15  

通过这个求值过程，很容易看出sum函数有明显的展开和收缩（收敛）过程。类似这样先展开/后收缩（收敛）的推迟求值的过程就是“ 递归计算过程”。
    知道了什么是“递归计算过程”后，再来瞧瞧“迭代计算过程”。代码在这里是最佳的说明，我们稍微改变一下sum函数用迭代计算过程来求值。

ruby 代码

1. def sum_iter(arr, resu = 0)  
2.   if arr.empty?  
3.     resu  
4.   else  
5.     resu += arr.shift  
6.     sum_iter(arr, resu)  
7.   end  
8. end  

ps: sum_iter的写法有时候也会被称为尾递归写法。怎么又是尾递归？稍安毋躁，我发誓接下来我一定会说到“尾递归”的！

它在1..5上的求值过程如下

ruby 代码

1. [1,2,3,4,5]  
2. [  2,3,4,5] + 1  
3. [    3,4,5] + 3  
4. [      4,5] + 6  
5. [        5] + 10  
6. [         ] + 15  
7. 15  

在这个计算过程中，平没有明显的展开和收缩（收敛）过程，在整个运行轨迹中我们只需保存变量resu。这种所有程序状态可以用固定个数的状态变量，以及一套固定的状态变量的修改规则就是“ 迭代计算过程”。相比递归计算过程，迭代计算过程有一个优点就是可以保存程序运行中的某个状态，然后下次运行的时候可以直接传递这个中间状态给该过程以恢复上次运算。你可以传递[4,5]和6给 sum_iter，它仍然能计算出15，而你传递[4，5]给sum，结果是9。

线性递归和树形递归
    也许当你看到sum和 sum_iter的时候，你更喜欢用for，foreach和while这样的循环来处理。实际上有一部分递归可以很容易地转换为循环，然而另一部递归却并不那么容易的进行转换。是否能容易转换为循环，取决于它是否是迭代/递归计算过程和线 性/树形递归。毫无疑问，拥有迭代计算过程的递归可以迅速转换为循环。迭代计算过程的递归和循环处理基本上是等价的，因此某个递归能不能转换为 迭代计算过程的递归也就决定了它能不能转换为循环处理。至于为什么要把递归转换为循环处理，可以看看【然而它工作得不过好】。
    现在我们可以回到这一节的主题线性/树形递归。性/树形递归这个其实很好理解，就像sum和 sum_iter这样的程序的计算步骤是随参数arr而线性增长的，这种过程就是线性递归。线性递归还可以细分为线性递归计算过程和线性迭代计算过程的递归，分别对应sum和 sum_iter。关于树形递归我就不多说了，可以很容易地联想到Tree这种结构。树形递归的也是先展开后收缩的，只不过它的展开后的求值过程是一棵树。这个不难联想到实际情况，例如自己写程序求某个目录下面的所有文件数或查找某个文件。但是这里有一点必须要注意。树形递归的效率比线性递归低得多。
例如，求fibonacci数

ruby 代码

1. def fib(n)  
2.   if n == 0 : 1  
3.   elsif n == 1 : 1  
4.   else  
5.     fib(n-2) + fib(n-1)  
6.   end  
7. end  
8.   
9. def fib_iter(n, a = 1, b = 0)  
10.   if n == 0 : a  
11.   else   
12.     fib_iter(n - 1, a + b, a)  
13.   end  
14. end  

这是在我机器上运行求fib(10)的结果，当求fib(100)的时候，已经慢得让我无法忍受了。

ruby 代码

1. require 'benchmark'  
2. include Benchmark  
3.   
4. bmbm(12) do |x|  
5.   x.report("fib") { 1000.times { fib(10) } }  
6.   x.report("fib_iter") { 1000.times { fib_iter(10) } }  
7. end  
8.   
9.                  user           system       total           real  
10. fib             0.265000   0.000000   0.265000 (  0.266000)  
11. fib_iter      0.016000   0.000000   0.016000 (  0.016000)  

    造 成这么大的差异的原因很大一部分是因为重复计算，例如求fib(10)的时候会求解fib(9) + fib(8)，然后求解fib(9)的时候仍然会再次求解fib(8)。当然这里有不少方法来提高树形递归的效率，但是其相对于线性递归的效率低下也是不 争的事实。这并不表明树形递归无用，在有些场合尤其是层次性数据的时候，非常有效。应为这种特殊场合比较难用线性递归或循环来处理，你需要懂懂脑子才能 （也许就想不出）办法把树形递归转换为线性递归或者循环处理。这里又不得不提性能，虽然我极力回避这个问题，但性能终究是一个问题。它使得你的程序运行的不那么好！