胡思乱想说递归-下

递归，迭代与循环

先说一下递归，迭代和循环的意义吧

• 递归(recursion)：指的是一个函数不断调用自身的行为
• 循环(loop)：指的是在满足条件的情况下，重复执行同一段代码的过程
• 迭代（iterate):按照某种顺序逐一访问某一项的方法

我们都知道递归由于存在函数调用时候的保存现场，入栈出栈的操作，会导致效率很低，在这问题规模不确定的时候是难以容忍的。

所以在很多时候，我们在写出来递归算法的时候，还要把递归转换成循环算法，这种转换要根据不同的问题来具体分析，甚至很多的时候还需要有很多的技巧。但是这些转换并不是毫无规律可言的，我们总结一下递归转换成循环的大致方向：

1. 建立一个自己的堆栈来保存递归中重要的局部变量。在递归算法中，这些局部变量是由系统自动为我们保存的。所以一般由递归算法转换成的循环算法，都必须要用到栈。二叉树的遍历是一个很好的证明。
2. 抽象出循环结构，把对于递归的调用，转换为循环处理。这里面最常见的是递归的步进表达式，在循环结构中依然会用来控制循环的执行。

说完递归和循环，在说一下迭代。迭代也是计算机解决问题的一种基本方法，利用计算机适合做重复性操作的特性，让计算机对一组指令重复执行，每次执行都会从变量的现有值推出一个新值。最常见的就是i*=n或者i+=n。

我们在使用迭代的时候，一般都会有三个要注意的地方:

1. 迭代变量的确定。在迭代算法中，至少会存在一个变量在每次迭代过程中直接或者间接的用新值来更新旧值。
2. 迭代关系的确定。在迭代算法中，采用什么样子的步骤去得出新值，并更新旧值。
3. 迭代终止条件的确定。如果没有终止条件，迭代就会无限进行下去。

一般有一些很经典的问题，可以用迭代来进行解决。比如上楼梯问题。
有一段楼梯总共有20阶，规定每一步只能上一阶或者两阶，那么要等上这20阶楼梯，总共有多少总走法。

下面分别用递归和迭代的解法来解决这个问题

递归解法

基本思想就是要上20阶，就需要上19阶或者18阶，从19阶到20阶只有一种走法，从18阶到20阶有两种走法，但是有一种走法是需要先到19阶在到20阶，这种走法已经算在了从19阶到20阶的走法里了，所以从18阶到20阶也只有一种走法，依次类推，就可以得知递归的解法了。

    //这其实就是一个斐波那契数列
    public static int stepCount(int N){
        if(N == 1){
            return 1;
        }else if(N == 2){
            return 2;
        }else{
            return stepCount(N-1)+stepCount(N-2);
        }
    }

那我们接下来看一下迭代的解法。
按照迭代的步骤，确定出迭代变量，在此题中就是走上N阶楼梯的步数steps。接下来确定迭代关系，就是steps(N)=steps(N-1)+steps(N-2)。从此我们可以看出来应该还有两个变量来记录N-1阶台阶的步数和N-2阶台阶的步数。迭代的终止条件是循环到N，所以我们可以得出来迭代的解法

迭代解法

    public static int stepCountIterator(int N){
        int steps = 0;
        int stepsN1 = 1;
        int stepsN2 = 0;
        for(int i = 1;i<=N;i++){
            steps = stepsN1+stepsN2;
            stepsN2 = stepsN1;
            stepsN1 = steps;
        }
        return steps;
    }

尾递归

我们知道递归效率非常低，比如斐波那契数列f(n)=f(n-1)+f(n-2),在计算f(n)的时候需要计算f(n-1)和f(n-2)，在计算f(n-1)的时候需要计算f(n-2)和f(n-3)，这样就在计算f(n)的时候，需要计算两次f(n-2)，这样造成很没有必要的浪费。

由于递归是靠系统自动为我们保存局部变量，如果我们手动的保存这些局部变量，并且在递归开始时把这些变量传递给递归方法，那么对于编译器来说，它就可以对这个过程进行优化(而且绝大部分编译器都对这个过程进行了优化)，这样递归调用的结果就可以直接返回，这样就把“线性递归”转化成了"线性迭代"，从而大大的提升效率。还是以斐波那契数列数列为例，我们应该怎么转换呢
由于斐波那契数列需要计算上一次和上上一次的和，所以我们需要增加两个参数来保存这两个值，同时，还需要增加一个参数来保存执行的次数。
改进后的斐波那契的计算过程是这样的：

    public static int fib(int n, int a1, int a2, intc){
        //其中a1和a2分别保存上一次和上上一次的计算结果
        if（n<=2）return 1；
        else{
            if(n==c) return a1+a2;
            else{
                return fib(n,a2,a1+a2,c+1);
            }
        }
    }

这就是采用尾递归的斐波那契数列的算法，他的效率已经和循环一样了。

看一下维基百科对尾递归的定义

尾递归是一种编程技巧，递归函数是指一些函数在内部会调用自己，如果递归调用的结果总是被直接返回，则成为尾部递归。尾部递归从编译器角度来看，容易被优化成普通循环，因为电脑只需要将函数调用的参数改变在重新调用一次，可以复用现有的堆栈，不需要重新开辟新的对战空间。尾递归的主要目的是优化。

尾递归在形式上来讲，递归方法处于方法的最后。而且由于编译器的优化，尾递归不会产生堆栈溢出的问题。

而且从上面也可以看出来，尾递归的核心思想是"把需要堆栈保存的状态变成参数传入到下一次调用中"。