对递归方法的见解

                 
    递归是在算法处理中，最常用的一种方法，也是一种比较经典的处理算

法的方法。
    递归是一种方法调用其自身的方法。这种调用的过程被称作递归

（recursion）,但是有时候递归很难处理，而有时却很方便实用，如果编程

中没有设定可以终止递归的条件检测，它会无限制的进行递归调用，因此在

用递归时要格外小心。
   递归一般可以代替循环语句使用，有些情况下使用循环比较好，而有些

时候使用递归更有效，递归方法方法虽然使程序结构优美，但其执行效率却

没有循环语句高。
  这个是一个利用递归和循环同时实现阶乘的代码，当你输入的数字逐渐增

大时，就会感动递归执行的越来越慢。
  import java.util.Scanner;
public class recursion
{
public static void main(String [] args)
{
Scanner input = new Scanner (System.in);
System.out.println("Please input other  number: ");
int n = input.nextInt();
System.out.println("Factorial of" + n + "is" + factorial(n));
Scanner input2 = new Scanner(System.in);
System.out.println("Please input another number: ");
int m = input2.nextInt();
System.out.println("method of" + m + "is" + method(m));
}
public static long factorial(int n)  //递归方法实现，
{
if (n==0)
    return 1;
else
    return n * factorial(n-1);
}
public static long method(int m)  //循环方法实现
{
long sum ;
for(sum=1;m>1;m--)
    sum *=m;
return sum;
}
}
数学中实现阶乘的思想是： 0！=1
n! = n*（n-1）* ...*2*1=n*(n-1)!;n>0
在这儿可以看出0!=1,是递归的终止条件。
而n*(n-1)! 是递归的核心数学思想。
用java实现的代码是，
if (n==0)
    return 1;
else
    return n * factorial(n-1);
}
    注意在递归中有一种特殊的用法，就是在递归方法自身内，直接调用自

己定义的这个方法，最典型的例子就是汉诺塔问题。
  实现代码如下：
import java.util.Scanner;


public class FacTest
{
static long l=0;
public static void main(String args[]) {
System.out.println("请输入盘子个数：");
Scanner s=new Scanner(System.in);
int n=s.nextInt();
System.out.println("汉诺塔层数为" + n);
System.out.println("移动方案为：" );
hanoi(n, 'a', 'b', 'c');
System.out.println("需要移动次数："+l);
}
static void hanoi(int n, char a, char b, char c)
{
if (n ==1 )
System.out.println("需要移动次数："+l);
else
{
hanoi(n - 1, a, c, b);
move(a, b);
hanoi(n - 1, c, b, a);
l++;
}
}

static void move(char x, char y)
{
System.out.println(x + "->" + y + "\t");
}
}
这个例子一直反复的自身调用。
由上面两个例子可以看出，最简单的递归方式是把递归语句放在函数结尾即

恰在return语句之前，这种是形式称作尾递归。
 递归虽然在一些算法处理中，很方便，但是递归还是有一定的缺点，最大

的缺点就是递归算法会很快耗尽计算机的内存资源。
斐波拉切也是一个递归的经典为题；
在这个代码中：
public static long Fibonacci(int n)
{
if(n>2)
return Fibonacci(n-1)*Fibonacci(n-2);
else
return 1;
}
在这个实现代码中，使用了双重递归（double recursion）,也就是说，方

法本身进行了两次调用，这样就会导致占用大量的内存。假设Fibonacci

(40).第一级递归会创建变量n,接着它两次调用，因为在第三级调用中需要

四个变量n,这是变量总数为7，因为每级调用需要的变量数是上一级的2倍，

所以这个变量个数是以指数的规律增长。因此，这样就会占用大量的内存。