1. package com.kxg;
   
2. 
   
3. /*
   
4. * 递归：方法定义中调用本身方法
   
5. *
   
6. * 注意：
   
7. *                 1.递归一定要有出口，否则就是死递归
   
8. *                 2.递归次数不能太对，否则就内存溢出
   
9. *                 3.构造方法不能使用递归
   
10. *
    
11. * 需求：递归实现5的阶乘
    
12. *                 5! = 5*4*3*2*1
    
13. *                 5! = 5*4!
    
14. */
    
15. public class DiGuiDemo {
    
16.         public static void main(String[] args) {
    
17.                 // 循环实现
    
18.                 int i = 1;
    
19.                 for (int x = 2; x <= 5; x++) {
    
20.                         i *= x;
    
21.                 }
    
22.                 System.out.println(i);
    
23. 
    
24.                 // 递归实现
    
25.                 System.out.println(JieCheng(5));
    
26.         }
    
27. 
    
28.         // 递归需要写一个方法：
    
29.         // 返回值类型：int 参数列表：int i
    
30.         // 出口条件： if(i == 1){ return 1;}
    
31. 
    
32.         private static int JieCheng(int i) {
    
33.                 if (i == 1) {
    
34.                         return 1;
    
35.                 } else {
    
36.                         return i * JieCheng(i - 1);
    
37.                 }
    
38.         }
    
39. }

复制代码

斐波那契数列问题：

1. package com.kxg;
   
2. 
   
3. import java.util.Scanner;
   
4. 
   
5. /*
   
6. * 斐波那契数列：
   
7. *                 1，1，2，3，5，8，13，21...
   
8. * 需求：求第n项的数字
   
9. */
   
10. public class TuZiDemo {
    
11.         public static void main(String[] args) {
    
12.                 Scanner sc = new Scanner(System.in);
    
13.                 System.out.println("你想查第几项：");
    
14.                 int num = sc.nextInt();
    
15. 
    
16.                 // 定义一个数组存储斐波那契数列
    
17.                 int[] arr = new int[num];
    
18. 
    
19.                 // 已知0和1索引的值为1
    
20.                 arr[0] = 1;
    
21.                 arr[1] = 1;
    
22. 
    
23.                 // 循环得到所有索引的值，并存储起来
    
24.                 for (int x = 2; x < arr.length; x++) {
    
25.                         arr[x] = arr[x - 1] + arr[x - 2];
    
26.                 }
    
27. 
    
28.                 // 所求n项在数组中为n-1项
    
29.                 System.out.println("数组实现：" + arr[num - 1]);
    
30. 
    
31.                 System.out.println("递归实现：" + ShenTu(num));
    
32.         }
    
33. 
    
34.         private static int ShenTu(int i) {
    
35.                 if (i == 1 || i == 2) {
    
36.                         return 1;
    
37.                 } else {
    
38.                         return ShenTu(i - 1) + ShenTu(i - 2);
    
39.                 }
    
40.         }
    
41. }

复制代码