如果要用Java实现算法,一定慎用递归

开发 后端 算法
递归是我们很经典的一种算法实现,可以很好的描述一个算法的原理!对于算法的描述、表现和代码结构理解上,递归都是不错的选择!

现象 :

递归是我们很经典的一种算法实现,可以很好的描述一个算法的原理!对于算法的描述、表现和代码结构理解上,递归都是不错的选择!

但是本文想说的是java实现一个递归算法的时候尽量不要用递归实现,而是转换成的非递归实现。

最近在实现一个比较复杂算法的时候,尝试了一下,非递归实现相比递归实现速度上能提升1/3。

以下面一个简单的例子来说:(注:为了描述简单,所以这里只用一个简单的例子)

输入参数:N

输出结果: log1+log2+log3+....+logN

两种实现代码如下:

Java代码

  1. package test;     
  2.     
  3. public class RecursiveTest {     
  4.     /**    
  5.      * 递归实现    
  6.      *     
  7.      * @param n    
  8.      * @return    
  9.      */    
  10.     public static double recursive(long n) {     
  11.         if (n == 1) {     
  12.             return Math.log(1);     
  13.         } else {     
  14.             return Math.log(n) + recursive(n - 1);     
  15.         }     
  16.     }     
  17.     
  18.     /**    
  19.      * 非递归实现    
  20.      *     
  21.      * @param n    
  22.      * @return    
  23.      */    
  24.     public static double directly(long n) {     
  25.         double result = 0;     
  26.         for (int i = 1; i <= n; i++) {     
  27.             result += Math.log(i);     
  28.         }     
  29.         return result;     
  30.     }     
  31.     
  32.     public static void main(String[] args) {     
  33.         int i = 5000000;     
  34.         long test = System.nanoTime();     
  35.         long start1 = System.nanoTime();     
  36.         double r1 = recursive(i);     
  37.         long end1 = System.nanoTime();     
  38.         long start2 = System.nanoTime();     
  39.         double r2 = directly(i);     
  40.         long end2 = System.nanoTime();     
  41.     
  42.         System.out.println("recursive result:" + r1);     
  43.         System.out.println("recursive time used:" + (end1 - start1));     
  44.         System.out.println("non-recursive result:" + r2);     
  45.         System.out.println("non-recursive time used:" + (end2 - start2));     
  46.     }     
  47. }    

 

得到运行结果如下:

 

  1. recursive result:7.212475098340103E7  
  2. recursive time used:539457109   
  3. non-recursive result:7.212475098340103E7  
  4. non-recursive time used:282479757  

 

可以看出递归的运行时间是非递归运行时间将近2倍。

(注:以上代码还是在-Xss200m的参数下运行的,如果栈空间不足,直接不能运行)

原因简单分析:

 

 

上图是java线程栈的结构。java将为每个线程维护一个堆栈,堆栈里将为每个方法保存一个栈帧,栈帧代表了一个方法的运行状态。 也就是我们常说的方法栈。***一个为当前运行的栈帧。

那么每一次方法调用会涉及:

1.为新调用方法的生成一个栈帧

2.保存当前方法的栈帧状态

3.栈帧上下文切换,切换到***的方法栈帧。

递归实现将导致在栈内存的消耗(往往需要调整Xss参数)和因为创建栈帧和切换的性能开销,最终大大的影响效率!

所以,如果你想提升你的算法效率,不要使用递归实现是一个基础原则!

另外,递归是我们用来理解算法的一个方法,当用代码来实现的时候基本都可以转换成非递归的代码实现!

【编辑推荐】

  1. JavaOne 2009第三天:微软与Sun/Oracle携手并进
  2. 开发高可移植性J2ME的软件
  3. Java虚拟机(JVM)中的内存设置详解
  4. Java中的堆内存与栈内存分配浅析
  5. 非常全面的实用JavaScript开发工具列表
责任编辑:金贺 来源: ITEYE博客
相关推荐

2022-08-31 22:50:13

JavaScript函数JSON

2020-08-30 14:31:40

Python编程语言开发

2021-01-14 10:38:41

Java枚举工具

2015-03-30 10:48:17

大数据大数据处理Hadoop

2019-01-21 08:20:17

通信4G5G

2017-09-28 08:35:35

前端HTML标签大全

2013-09-03 09:09:30

大数据

2021-02-26 09:04:22

数组ArrayListHashMap

2018-08-24 09:02:26

2015-06-17 11:18:01

WiFi

2022-02-18 12:24:39

PythonNumpy Arra大数据

2016-09-21 22:12:43

网络爬虫Java开源

2022-08-26 08:17:32

Webshiro关系

2021-01-19 11:00:14

CPU核心单核

2019-11-12 08:53:00

线上命令日志

2022-08-01 07:07:41

TCP协议后端

2017-01-19 17:57:47

大数据

2015-03-17 15:18:02

私有云公共云数据中心

2022-12-26 09:16:45

Guava架构模型

2016-11-28 11:19:48

术语神秘
点赞
收藏

51CTO技术栈公众号