递归和迭代

1、递归

n=1    
  一步    
   f(1)=1;

n=2    
（1）一步一步走  
（2）直接跨两步  
  f(2)=2;

n=3      
(1) 先到到f(1),然后从f(1)直接跨2步  
（2）先到到f(2),然后从f(2)直接跨1步 
 f(3)=f(1)+f(2)

n=4      
(1) 先到到f(2),然后从f(2)直接跨2步 
 （2）先到到f(3),然后从f(3)直接跨1步
   f(4)=f(2)+f(3)

n=x
(1) 先到到f(x-2),然后从f(x-2)直接跨2步  
（2）先到到f(x-1),然后从f(x-1)直接跨1步 
 f(x)=f(x-2)+f(x-1)

代码：

import org.junit.jupiter.api.Test;

public class TestStep {
    //实现符（n）：求n步台阶，一共有几种走法
    public int f(int n){
        if (n<1){
            throw new IllegalArgumentException(n+"不能小于1");
        }
        if (n==1||n==2){
            return n;
        }
        return f(n-2)+f(n-1);
    }

    @Test
    public void test(){
        long start=System.currentTimeMillis();
        //System.out.println(f(0));
        System.out.println(f(1));
        System.out.println(f(2));
        System.out.println(f(3));
        System.out.println(f(4));
        System.out.println("台阶为40时一共  "+f(40)+"  种走法");
        long end=System.currentTimeMillis();//毫秒
        long time=end-start;
        System.out.println("总运行时间："+time+" 毫秒");
    }
}

运行结果：

1
2
3
5
台阶为40时一共  165580141  种走法
总运行时间：407 毫秒

2、循环迭代

n=1      
一步    
 f(1)=1;

n=2  
  （1）一步一步走  
  （2）直接跨两步
     f(2)=2;

n=3  
    (1) 先到到f(1),然后从f(1)直接跨2步  
    （2）先到到f(2),然后从f(2)直接跨1步
      one=f(1); 
       two=f(2);  
       f(3)=one+two;  
       即f(3)=f(1)+f(2)

n=4     
 (1) 先到到f(2),然后从f(2)直接跨2步  
 （2）先到到f(3),然后从f(3)直接跨1步  
  one=f(2);  
  two=f(3);  
  f(4)=one+two; 
   即f(4)=f(2)+f(3)

n=x   
   (1) 先到到f(x-2),然后从f(x-2)直接跨2步 
    （2）先到到f(x-1),然后从f(x-1)直接跨1步  
     one=f(x-2);  
     two=f(x-1); 
      f(x)=one+two; 
       即f(x)=f(x-2)+f(x-1)

代码：

import org.junit.jupiter.api.Test;

public class testStep2 {
    //实现符（n）：求n步台阶，一共有几种走法
    public int loop(int n) {
        if (n < 1) {
            throw new IllegalArgumentException(n + "不能小于1");
        }
        if (n == 1 || n == 2) {
            return n;
        }
        int two = 2;//初始化走到第二级台阶有2种走法
        int one = 1;//初始化走到第一级台阶有1种走法
        int sum = 0;
        for (int i = 3; i <= n; i++) {
            //比如i=3: 总步数sum=如果最后跨2步那么还有一级可走（即one）+如果最后跨1步那么还有两级可走（即two）
            //同理：i=4:总步数sum=如果最后跨2步那么还有两级可走（即one=i是3的时候的two）+如果最后跨1步那么还有三级可走（即two=i是3的时候的sum）
            //所以有以下步骤：
            sum=one+two;
            one=two;
            two=sum;
        }
        return sum;
    }

    @Test
    public void test() {
        long start = System.currentTimeMillis();
        //System.out.println(f(0));
        System.out.println(loop(1));
        System.out.println(loop(2));
        System.out.println(loop(3));
        System.out.println(loop(4));
        System.out.println("台阶为40时一共  " + loop(430) + "  种走法");
        long end = System.currentTimeMillis();//毫秒
        long time = end - start;
        System.out.println("总运行时间："+time+" 毫秒");
    }
}

运行结果：

1
2
3
5
台阶为40时一共  -941745183  种走法
总运行时间：0 毫秒

总结：

方法调用自身称为递归，利用变量的原值推出新值称为迭代。

递归：
   优点：大问题转换成小问题，可以减少代码量，同时代码精简，可读性好；
   缺点：递归浪费了空间，而且递归太容易造成堆栈的溢出。

迭代：
   优点：代码运行效率好，因为时间只因循环的次数增加而增加，而且没有额外的空间·开销；
   缺点：代码不如递归简洁，可读性好