算法学习之递归和堆栈

【摘要】当执行完被调用函数，返回外部程序前，系统首先要恢复外部程序的变量当前值，然后返回外部程序的返回地址。递归函数被外部程序调用时，系统要做的工作和非递归函数被调用时系统要做的工作在形式上类同，只是实现方法不同而已。那递归代码和运行时的堆栈有什么关系呢？我们先看一下下面这几幅图，关于递归代码和运行时堆栈关系。

    

我们可以看一下普通函数的调用怎么样的。试想如果函数A调用了函数B，函数B又调用了函数C，那么在堆栈中的数据是怎么保存的呢？

[cpp] view plaincopy

1. 函数A    ^  
2. 函数B    |    (地址递减)  
3. 函数C    |  

    如果是递归函数呢，举一个简单的递归函数为例：

[cpp] view plaincopy

1. int iterate(int value)  
2. {  
3.     if(value == 1)  
4.         return 1;  
5.     return value + iterate(value -1);  
6. }  

    下面我们使用一个函数进行调用，看看会发生什么情况？

[cpp] view plaincopy

1. void process()  
2. {  
3.     int value = iterate(6);  
4. }  

    看看此时内存堆栈是什么样的？

[cpp] view plaincopy

1. iterate(int 1) line 96  
2. iterate(int 2) line 97 + 12 bytes  
3. iterate(int 3) line 97 + 12 bytes  
4. iterate(int 4) line 97 + 12 bytes  
5. iterate(int 5) line 97 + 12 bytes  
6. iterate(int 6) line 97 + 12 bytes  
7. process() line 102 + 7 bytes  
8. main() line 108  
9. mainCRTStartup() line 206 + 25 bytes  
10. KERNEL32! 7c817067()  

    大家也看到了上面的代码，递归函数和普通的函数也没有什么差别。除了自己调用本身之外，他就是一个普通的函数。那么这个函数递归到什么时候返回呢？这就是递归函数的关键了。我们看到iterate函数到1就停止了，所以上面的堆栈在（value == 1）即return。所以一个递归函数最关键的部分就是两点：（1）递归策略；（2）函数出口。

    看到这里，大家可能感到递归函数不过如此，事实上也是这样。但是，还有一点大家需要牢记在心，递归的深度是我们必须考虑的一个问题。只有递归深度在一个可控的范围内，那么整个递归过程都是可控的。那什么时候不可控呢？那就是递归深度超过了一定的数字？这个数字和具体的线程堆栈长度有关？等到堆栈溢出了，那么获得的数据已经失去了真实性，所以也就没有意义了。

    我们把上面的问题推广一下，如何用自己定义的堆栈模拟上面的递归调用呢？这样既能满足递归的属性，又能确保函数深度可控。

[cpp] view plaincopy

1. int iterate(int value)  
2. {  
3.     int count = 0;  
4.     int number  =0;  
5.   
6.     push(value);  
7.     while(-1 != (number = pop()))  
8.     {  
9.         if(1 != number)  
10.             push(number -1);  
11.         count += number;  
12.     }  
13.   
14.     return count;  
15. }