递归与尾递归

递归算法是一种直接或者间接调用自身函数或者方法的算法。
递归算法的实质是把问题分解成规模缩小的同类问题的子问题，然后递归调用方法来表示问题的解。
递归算法对解决一大类问题很有效，它可以使算法简洁和易于理解。递归算法，其实说白了，就是程序的自身调用。它表现在一段程序中往往会遇到调用自身的那样一种coding策略，这样我们就可以利用大道至简的思想，把一个大的复杂的问题层层转换为一个小的和原问题相似的问题来求解的这样一种策略。递归往往能给我们带来非常简洁非常直观的代码形势，从而使我们的编码大大简化，然而递归的思维确实很我们的常规思维相逆的，我们通常都是从上而下的思维问题， 而递归趋势从下往上的进行思维。这样我们就能看到我们会用很少的语句解决了非常大的问题，所以递归策略的最主要体现就是小的代码量解决了非常复杂的问题。
递归算法解决问题的特点：
1）递归就是方法里调用自身。
2）在使用递增归策略时，必须有一个明确的递归结束条件，称为递归出口。
3）递归算法解题通常显得很简洁，但递归算法解题的运行效率较低。所以一般不提倡用递归算法设计程序。
4）在递归调用的过程当中系统为每一层的返回点、局部量等开辟了栈来存储。递归次数过多容易造成栈溢出等，所以一般不提倡用递归算法设计程序。
在做递归算法的时候，一定要把握住出口，也就是做递归算法必须要有一个明确的递归结束条件。这一点是非常重要的。其实这个出口是非常好理解的，就是一个条件，当满足了这个条件的时候我们就不再递归了。
二、程序示例
①斐波纳契数列（Fibonacci Sequence）
问题描述：求解Fibonacci数列的第n个位置的值？（斐波纳契数列（Fibonacci Sequence），又称黄金分割数列，指的是这样一个数列：1、1、2、3、5、8、13、21、……在数学上，斐波纳契数列以如下被以递归的方法定义：F1=1,F2=1,Fn=F（n-1）+F（n-2）（n>2,n∈N*））。

#include<iostream>
#include<stdio.h>
#include<math.h>


using namespace std;
int fun(int n);
int  fun(int n)
{
    int count ;
    if(n == 1 || n == 2){

        return 1; 
    }
    else
    {
        count=fun(n -1)+fun(n-2);
        return count ;
    }
}
int main (int argc,char *argv[])
{
    int result;
    result  = fun(5);
    printf("%d\n",result);
    return 0;
}

运行结果：

5
Press any key to continue

     程序分析：这个实例是非常经典的实例，主要是利用递归实现了Fibonacci数列。这个递归算法的出口是在

[java] view plaincopy
if(index==1 || index==2){
return 1;
}
这个代码段上，如果程序的index符合条件就会停止进行递归。所以这个程序的运行流程是：

      刚才说了这个方法十几度危险的，为什么这么说，原因在于在这个递归里做了冗余的工作，如图，我们在f4里面已经计算了f2，可是f3里有同样计算了f2，以此类推那些冗余的工作，在数值比较小的情况下，计算机还是可以接受的。但是，当求解的数值比较大，它是成指数级增长的，所以不要再递归中做重复的工作。
  ②n的阶乘
        问题描述：求5的阶乘
         求解代码：

[java] view plaincopy
public class Factorial_Five {

/** 
 * time:2012.12.2 
 * author:王金宇 
 * description:递归求n的阶乘 
 */  
public static void main(String[] args) {  
    Factorial_Five factorial_Five=new Factorial_Five();  
    int result=factorial_Five.factorial(5);  
    System.out.println(result);  
}  
public int factorial(int index){  
    if(index==1){  
    return 1;  
    }else{  
    return factorial(index-1)*index;  
    }  
}  

}

三、递归算法转换成非递归算法
递归算法实际上是一种分而治之的方法，它把复杂问题分解为简单问题来求解。对于某些复杂问题(例如hanio塔问题)，递归算法是一种自然且合乎逻辑的解决问题的方式，但是递归算法的执行效率通常比较差。因此，在求解某些问题时，常采用递归算法来分析问题，用非递归算法来求解问题；另外，有些程序设计语言不支持递归，这就需要把递归算法转换为非递归算法。将递归算法转换为非递归算法有两种方法，一种是直接求值，不需要回溯；另一种是不能直接求值，需要回溯。前者使用一些变量保存中间结果，称为直接转换法；后者使用栈保存中间结果，称为间接转换法，下面分别讨论这两种方法。
　　
1. 直接转换法
　　直接转换法通常用来消除尾递归和单向递归，将递归结构用循环结构来替代。尾递归是指在递归算法中，递归调用语句只有一个，而且是处在算法的最后。例如求阶乘的递归算法：
　public long fact(int n)
　　{
　　if (n==0) return 1;
　　else return n*fact(n-1);
　　}
　　当递归调用返回时，是返回到上一层递归调用的下一条语句，而这个返回位置正好是算法的结束处，所以
，不必利用栈来保存返回信息。对于尾递归形式的递归算法，可以利用循环结构来替代。例如求阶乘的递归算法
可以写成如下循环结构的非递归算法：
　　public long fact(int n)
　　{
　　int s=0;
　　for (int i=1; i
　　s=s*i; //用s保存中间结果
　　return s;
　　}
　　单向递归是指递归算法中虽然有多处递归调用语句，但各递归调用语句的参数之间没有关系，并且这些递归
调用语句都处在递归算法的最后。显然，尾递归是单向递归的特例。例如求斐波那契数列的递归算法如下：
　　public int f(int n)
　　{
　　if (n= =1 | | n= =0) return 1;
　　else return f(n-1)+f(n-2);
　　}
　　对于单向递归，可以设置一些变量保存中间结构，将递归结构用循环结构来替代。例如求斐波那契数列的算
法中用s1和s2保存中间的计算结果，非递归函数如下：
　　public int f(int n)
　　{
　　int i, s;
　　int s1=1, s2=1;
　　for (i=3; i {
　　s=s1+s2;
　　s2=s1; // 保存f(n-2)的值
　　s1=s; //保存f(n-1)的值
　　}
　　return s;
　　}
　　2. 间接转换法
　　该方法使用栈保存中间结果，一般需根据递归函数在执行过程中栈的变化得到。其一般过程如下：
　　将初始状态s0进栈
　　while (栈不为空)
　　{
　　退栈，将栈顶元素赋给s;
　　if (s是要找的结果) 返回;
　　else {
　　寻找到s的相关状态s1;
　　将s1进栈
　　}
　　}
　　间接转换法在数据结构中有较多实例，如二叉树遍历算法的非递归实现、图的深度优先遍历算法的非递归实现等等，请读者参考主教材中相关内容。
2. 列表内容