为什么超出了内存限制，我该如何避免这种情况？答案

【问题标题】：Why was the memory limit exceeded and how can I avoid this?为什么超出了内存限制，我该如何避免这种情况？
【发布时间】：2018-12-18 14:27:49
【问题描述】：

代码

import java.util.*;

public class AlmostPerfect {

    public static void main(String[] args) {
        Scanner x = new Scanner(System.in);

        while(x.hasNext()) {
            int n = x.nextInt();
            int sum = recursion(n, n-1, 0);
            if (sum == n) {
                System.out.println(n + " perfect");
            } else if ((n - sum) <= 2) {
                System.out.println(n + " almost perfect");
            } else {
                System.out.println(n + " not perfect");
            }
        }
    }

    public static int recursion(int n, int x,int sum) {

        if(x == 0){
            return sum;
        }
        else if (n % x == 0) {
            sum += x;
            return recursion(n, x-1, sum);
        }
        else{
            return recursion(n, x-1, sum);
        }
    }
}

我想基本上找出我的解决方案有什么问题...有一个解决方案，但我无法理解超出内存限制的属性。

问题链接：https://open.kattis.com/problems/almostperfect

【问题讨论】：

n 可以达到十亿。想想最坏的情况：当n 的值为1e9 时，堆栈会发生什么？此外，您的代码和优化范围中还有一些其他错误。
你为什么要使用递归？一个简单的循环就可以了。
@Andreas 任何可以用循环完成的事情都可以用递归完成，反之亦然。
@EvOlaNdLuPiZ 当然，如果您维护自己的回溯信息堆栈，任何递归都可以写成循环，但代码可能更复杂。但是，this 代码不需要任何回溯信息，因此可以通过 simple 循环来完成。
递归将通过保留旧的递归变量在 OutOfMemory 上运行，或者如果调用堆栈达到 Integer.MAX_VALUE 的大小，则在 StackOverflowException 上运行。无论先出现什么，最好的解决方案是使用 for 循环

标签： java recursion memory limit

【解决方案1】：

如果您必须更喜欢递归解决方案，您可以限制递归的深度，以避免堆栈溢出。

您可以在连续的时间间隔内运行递归解决方案，一次一个时间间隔：

import java.util.stream.IntStream;

public class AlmostPerfect {

    // Defines the recursive iteration depth. increase it and you run into
    // Stack overflow
    private static int RECURSION_DEPTH = 5000;

    public static void main(String[] args) {

        // Run comparison test between recursive and non recursive solutions
        IntStream.range(1, 200000).forEach(i -> {

            double sumRecursive = recursionWithLimitedDepth(i);
            double sumIterative = iterative(i);

            if((sumRecursive != sumIterative)) {
                System.out.println("for " + i + " " + sumRecursive + "<>" + sumIterative);
                return;
            }

            if((i%20000) == 0) {
                System.out.println("20,000 numbers successfully checked");
            }
        });

        System.out.println("Test finished");
    }

    // Helper method for recursive solution
    public static double recursionWithLimitedDepth(int n) {

        double sum = 0;
        int rangeStart = n-1;
        int rangeEnd = rangeStart - RECURSION_DEPTH;

        while (rangeStart > 0) {
            sum += recursionWithLimitedDepth(n, rangeStart, rangeEnd, 0);
            rangeStart = (rangeEnd - 1) >= 0 ? rangeEnd - 1 : 0;
            rangeEnd = (rangeStart - RECURSION_DEPTH) >= 0 ? rangeStart - RECURSION_DEPTH : 0;
        }

        return sum;
    }

    // Run recursive solution on a limited range defined by rangeStart, rangeEnd
    public static double recursionWithLimitedDepth(int numberToTest, int rangeStart,
                                                   int rangeEnd, double sum) {
        if(rangeStart == 0) {
            return sum;
        }
        else if ((numberToTest % rangeStart) == 0) {
            sum += rangeStart;
        }

        if(rangeStart == rangeEnd) {
            return sum;
        }

        return recursionWithLimitedDepth(numberToTest, rangeStart-1, rangeEnd, sum);
    }

    // Simple iterative to test against
    public static double iterative(int n) {

        double sum = 0;

        for(int x = n-1; x > 0; x--) {
            if((n%x) == 0) {
                sum += x;
            }
        }
        return sum;
    }
}

注意sum 是double 以避免Integer 溢出（使用Integer.MAX_VALUE 测试）。

【讨论】：