循环？还是递归？

最新推荐文章于 2022-07-23 12:57:44 发布

xcbeyond

最新推荐文章于 2022-07-23 12:57:44 发布

阅读量430

点赞数 2

本文链接：https://blog.csdn.net/xcbeyond/article/details/100984293

版权

640?wx_fmt=jpeg

前言

前几天群里有几个小伙伴，展开了如下讨论：

--------------------------------------------------------------------------

【西安-Java-小白】

谁遇上过？

640?wx_fmt=png

【杭州-Java-JOEL】

你要打断点看哪行出错了

【西安-Java-小白】

栈溢出，mybatis执行查询的时候，循环查询，1000条查询一次，到160多次的时候栈溢出

【北京-Android-背影】

你有递归么

【西安-Java-小白】

嗯。刚把递归干掉了，换成循环试试。

【北京-Android-背影】

@西安-Java-小白你去掉递归还会报错么

一般栈溢出都是有递归调用方法体导致的

【西安-Java-小白】

嗯

去掉了，在测试

换成while了

【北京-Android-背影】

嗯嗯，等会给我们说下结果

【西安-Java-小白】

感觉速度比递归快太多了

【杭州-Java-JOEL】

查询的时候批量去查稍微好点

【北京-Android-背影】

递归方法体内的变量会一直保存，但是有的变量没任何意义。

循环的话，方法体内的变量会被回收掉，不会一直占内存。

【杭州-Java-JOEL】

这个解释赞

【西安-Java-小白】

嗯呢

改成循环就OK了

【西安-Java-xcbeyond】

栈，主要是用来存放栈帧的，每执行一个方法就会出现压栈操作，所以采用递归的时候产生的栈帧比较多，递归就会影响到内存，非常消耗内存。而使用循环就执行了一个方法，压入

栈帧一次，只存在一个栈帧，所以比较节省内存。

--------------------------------------------------------------------------

都是递归惹的祸！接下来，我们就一起讨论下递归和循环吧，该如何用，他们都有哪些区别呢？时间复杂度，空间复杂度又是多少呢

循环、递归验证

循环：当满足某一条件时，进行反复执行某一操作(循环体)。如： for、while循环

递归：在一个方法内调用方法本身，并且要有递归结束的判断。

循环和递归两者之间是可以相互替换实现的，但他们之间却有很大的差异，其时间复杂度，空间复杂度有着很大的差异的。

接下来，我们就直接撸起代码见效果吧，以一个整数递减到0输出为例。

package com.xcbeyond.test;	

	
/**	
 * 递归测试	
 * @Auther: xcbeyond	
 * @Date: 2019/9/12 11:26	
 */	
public class RecursionTest {	

	
    public static void main(String [] args) {	
        int number = 5000;	

	
        long startTime = System.currentTimeMillis();	
        loop(number);	
        long endTime = System.currentTimeMillis();	
        System.out.println();	
        System.out.println("循环耗时：" + (endTime-startTime));	

	

	
        long startTime2 = System.currentTimeMillis();	
        recursion(number);	
        long endTime2 = System.currentTimeMillis();	
        System.out.println();	
        System.out.println("递归耗时：" + (endTime2-startTime2));	
    }	

	
    /**	
     * 递归	
     * @param n	
     * @return	
     */	
    public static void recursion(int n) {	
        if(n <= 0) {	
            return;	
        }else {	
            System.out.print(n + " ");	
            recursion(n - 1);	
        }	
    }	

	
    /**	
     * 循环	
     * @param n	
     * @return	
     */	
    public static void loop(int n) {	
        for(int i = n; i> 0;i--) {	
            System.out.print(i + " ");	
        }	
    }	
}

结果分析：

number分别为1000、5000、10000，其耗时结果如下:

情况1：1000

循环耗时：34	
递归耗时：18

情况2：5000

循环耗时：48	
递归耗时：11

情况3：10000

循环耗时：142	
Exception in thread "main" java.lang.StackOverflowError	
at sun.nio.cs.UTF_8$Encoder.encodeLoop(UTF_8.java:691)	
  at java.nio.charset.CharsetEncoder.encode(CharsetEncoder.java:579)	
  at sun.nio.cs.StreamEncoder.implWrite(StreamEncoder.java:271)	
  at sun.nio.cs.StreamEncoder.write(StreamEncoder.java:125)	
  at java.io.OutputStreamWriter.write(OutputStreamWriter.java:207)	
  at java.io.BufferedWriter.flushBuffer(BufferedWriter.java:129)	
  at java.io.PrintStream.write(PrintStream.java:526)	
  at java.io.PrintStream.print(PrintStream.java:669)	
  at com.xcbeyond.test.RecursionTest.recursion(RecursionTest.java:36)

从上述结果来看，使用循环算法比递归算法更耗时，但当循环、递归次数达到一定数据级时，递归算法就会出现栈溢出(StackOverflowError)问题了，这也就是文章开头说的现象了。

针对栈溢出问题，我们可以进一步来跟踪如下：

(上述代码略做修改，为了便于观察，number设置为5)

package com.xcbeyond.test;	

	
/**	
 * 递归测试	
 * @Auther: xcbeyond	
 * @Date: 2019/9/12 11:26	
 */	
public class RecursionTest {	

	
    public static void main(String [] args) {	
        int number = 3;	

	
        long startTime = System.currentTimeMillis();	
        loop(number);	
        long endTime = System.currentTimeMillis();	
        System.out.println();	
        System.out.println("循环耗时：" + (endTime-startTime));	

	

	
//        long startTime2 = System.currentTimeMillis();	
//        recursion(number);	
//        long endTime2 = System.currentTimeMillis();	
//        System.out.println();	
//        System.out.println("递归耗时：" + (endTime2-startTime2));	
    }	

	
    /**	
     * 递归	
     * @param n	
     * @return	
     */	
    public static void recursion(int n) {	
        Thread.currentThread().dumpStack();	
        if(n <= 0) {	
            return;	
        }else {	
            System.out.print(n + " ");	
            recursion(n - 1);	
        }	
    }	

	
    /**	
     * 循环	
     * @param n	
     * @return	
     */	
    public static void loop(int n) {	
        for(int i = n; i> 0;i--) {	
            System.out.print(i + " ");	
            Thread.currentThread().dumpStack();	
        }	
    }	
}

循环的栈分配情况：

640?wx_fmt=png