Java零基础—方法递归

什么是递归：方法自身调用自身即为递归。

递归很耗费栈内存，能不使用尽量不使用；但有些情况下该功能实现必须依赖递归，例如目录的拷贝。

递归必须有结束条件，没有结束条件一定会发生栈内存溢出错误；递归即使有了结束条件，即使结束条件正确，也可能会发生栈内存溢出错误。

不使用递归，计算1~N的和：

 1 /**
 2   不使用递归计算1~N的和。
 3 */
 4 public class RecursionTest01{
 5     public static void main(String[] args){
 6         //计算1~4的和
 7         int n = 4;
 8         int retValue = sum(n);
 9         System.out.println("sum = " + retValue);
10     }
11     
12     public static int sum(int n){
13         int result = 0;
14         for(int i = 1; i <= n; i ++){
15             result += i;
16         }    
17             return result;
18     }
19 }

使用递归计算1~N的和：

 1 /**
 2   使用递归计算1~N的和。
 3 */
 4 public class RecursionTest02{
 5     public static void main(String[] args){
 6         //计算1~4的和
 7         int n = 4;
 8         int retValue = sum(n);
 9         System.out.println(retValue);
10     }
11     
12     public static int sum(int n){
13         if(n == 1){
14                 return 1;
15             }
16         
17             return n + sum(n-1);
18     }
19 }

使用递归计算1~4时的内存分析

 

 

例：计算N的阶乘。分别使用递归、不使用递归

 1 /**
 2   计算N的阶乘
 3 */
 4 public class RecursionTest03{
 5     public static void main(String[] args){
 6         //计算n的阶乘
 7         int n = 5;
 8         int retValue1 = method1(n);
 9         int retValue2 = method1(n);
10         System.out.println(retValue1);
11         System.out.println(retValue2);
12     }
13     
14     //不使用递归计算
15     public static int method1(int n){
16         int result = 1;
17         for(int i = 1; i <= n; i++){
18             result *= i;
19         }
20             return result;
21     }
22     
23     //使用递归计算
24     public static int method2(int n){
25             if(n == 1){
26                     return 1;
27                 }
28             return n * method2(n-1);
29     }
30 }

总结：

 

posted on 2021-02-23 21:50  AnYeYiYang  阅读(79)  评论(0)  编辑  收藏  举报

导航