迭代与递归

这两个概念好像有点相似，就连字都长得有点像...
简单阐述一下他们的联系吧。
反正我也不懂，你们要是批评我也没办法╮(╯▽╰)╭

---

他山之玉（from 知乎）：

递归，简讲就是自己调用自己，自己包含自己。
迭代是将输出做为输入,再次进行处理。

大意是递归过程中, 问题的规模在缩小，这样最终得到问题的解；而迭代是一种由远变近的逼近，问题的规模不见得缩小了，但是慢慢在调整接近答案。

递归是自己调用自己，每次旨在缩小问题规模。迭代是自己执行很多次，每次旨在更接近目标。

迭代是逐渐逼近，用新值覆盖旧值，直到满足条件后结束，不保存中间值，空间利用率高。
递归是将一个问题分解为若干相对小一点的问题，遇到递归出口再原路返回，因此必须保存相关的中间值，这些中间值压入栈保存，问题规模较大时会占用大量内存。

递归recursive：

我的理解是，有一个固定的入口，但是要出去就要有一定条件了。
进来以后开始对数据进行加工，但是在函数加工之后并不是就停止了，
而里面包含了继续的调用自己。
虽然是调用自己的函数，但是参数发生了变化，参数变得越来越接近那个终止条件了。当层层迭代直至满足终结条件时，回溯至岁月往昔（也就是那个入口）。
因此，最后的一个返回值包含了多个之前返回的内容。

     {
       if(n == 0)
            return 0;
      else
            return  n+rec(n-1);
      }

就以上例为例，
我的猜测应该是这样：

rec(5)
=5+rec(4)
=5+4+rec(3)
=5+4+3+rec(2)
=5+4+3+2+rec(1)
=5+4+3+2+1+rec(0)

每次的调用，都是在向着停止条件（n=0）接近，直到达到时，再返回。

以下是vs调试的过程：

1.png

进一步执行：

2.png

我们可以看到，每一次的执行之后，递归深度都会变得更大。
递归深度这个词看起来有些高级，其实也就是调动的层次。

3.png

然而，你会发现，并不是在n=0时就停止了，而是向上，n再变回去，再次回到n=5。

恩，所以说，刚刚那个还有继续的过程：

5+4+3+2+1+rec(0)
=5+4+3+2+1+0
=5+4+3+2+1
=5+4+3+3
=5+4+6
=5+10
=15

同时，递归深度也变小了。（回到岁月往昔....）

按照这个原理，还能去写个斐波那契数列的：

 int fib(int n)  
{  
   if(n == 0)  
       return 0;  
   if(n == 1)  
       return 1;  
   if(n > 1)  
       return fib(n-1)+fib(n-2);  
} 

再来说说迭代。

迭代 iteration

先看段代码：

int iter(int n)
{
    int ret = 0;
    for(int i = 1;  i <= n; i++)
              ret = ret + i;
    return ret;
}

这个看起来就眼熟多了，好像在平时我们见到的大多数循环都是这个样子。
迭代就是调用自己的一部分，反复循环重复，直到需要的地步然后输出。

举一个豌豆的例子：

假如我们像孟德尔一样在种豌豆，我们把黄而圆的豌豆和绿而皱的杂交，
YYRR x yyrr
当然我们知道子一代是YyRr，
它们看起来和黄圆形状一样，但是本质上，已经不纯了。

为了尽快的更多的得到较接近黄圆形状的，我们就会采取这样的做法
YyRr x YYRR
(在不考虑区分的情况下)

这个过程可以和迭代放到一起，不断的和某个部分变得相似，并且在变得过程中本身发生着变化。

其目的通常是为了逼近所需目标或结果。（接近纯合YYRR）
每一次对过程的重复称为一次“迭代”（杂交过程），
而每一次迭代得到的结果（子代）会作为下一次迭代的初始值（亲代）。
按照迭代，还能再写个斐波那契数列：

int fib(int n) {  
    int result[2] = { 0, 1 };  
    int i;  
    int num = 0;  
    if(n < 2) {  
        return result[n];  
    }  
   int one = 1;  
   int two = 0;  
    for(i=2;i <=n;i++) 
{  
        num = one + two;  
        two = one;  
        one = num;  
    }  
    return num;  
} 

总结

为了更好的说明问题，
这是网上一位前辈总结的表格：

表格.png

又出现了一个新名词：堆栈溢出，这又是什么？

以下引用百度百科
：

堆栈溢出的产生是由于过多的函数调用，导致调用堆栈无法容纳这些调用的返回地址，一般在递归中产生。堆栈溢出很可能由无限递归（Infinite recursion）产生，但也可能仅仅是过多的堆栈层级。
不懂。

嗯，百度大概觉得自己也没讲明白，又补充：

堆栈溢出就是不顾堆栈中分配的局部数据块大小，向该数据块写入了过多的数据，导致数据越界，结果覆盖了别的数据。 可以理解为 在长字符串中嵌入一段代码，并将过程的返回地址 覆盖为 这段代码的地址，这样当过程返回时，程序就转而开始执行这段自编的代码了。

大概就是说数据越界造成错误吧，有一段简单的代码说明了这个问题：

#include
int main()
{
char name[8];
printf("Please type your name:");
gets(name);
printf("Hello.%s!",name);
return 0;
}

一般来说，我们也不会超出这8个字符的，可是要是你调皮非要多输几个，AAAAAAAAAAAAA
由于我们输入的name字符串太长，name数组容纳不下，只好向内存顶部继续写'A'，而此例由于堆栈的生长方向与内存的生长方向相反，这些'A’覆盖了堆栈的老的元素。在main返回的时候，就会把'AAAA'的ASCII码：0x41414141作为返回地址，CPU会试图执行0x41414141处的指令，结果出现错误。这就是一次堆栈溢出。

大概就是这样，以后深入理解后再补充吧。