小编use*_*335的帖子

我的问题是,当我使用递归时,我通常会得到一个java.lang.StackOverflowError.我的问题是 - 为什么递归导致stackoverflow比循环更多,并且是否有任何使用递归来避免堆栈溢出的好方法？

这是一个解决问题107的尝试,它适用于他们的示例,但是为了自身的问题耗尽了堆栈空间.

//-1 16 12 21 -1 -1 -1 16 -1 -1 17 20 -1 -1 12 -1 -1 28 -1 31 -1 21 17 28 -1 18 19 23 -1 20 -1 18 -1 -1 11 -1 -1 31 19 -1 -1 27 -1 -1 -1 23 11 27 -1
public class tries
{
    public static int n=7,min=Integer.MAX_VALUE;
    public static boolean[][] wasHere=new boolean[n][60000];
    public static void main(String[] args)
    {
        int[] lines=new int[n]; Arrays.fill(lines, -1000); lines[0]=0; …

例如，大小为32的布尔数组会比整数变量占用更多空间吗？如果是这样，那为什么又要增加多少？

澄清：

在Java中（如果相关，请原谅我-我不确定）。这行：

boolean arr=new boolean[32];

比此行占用更多空间：

int num;

我最近编写了一个代码,这里是它的相关部分:

int n=100000;
int[] euler=new int[n+1],arr=new int[n+1],brr=new int[n+1]; 
ArrayList[] list = new ArrayList[n+1]; //reverse euler. list[4]=5,8,10,12.
use.makeEuler(euler); 
for(int i=7; i<=n; i++)
    brr[euler[i]]++;
for(int i=7; i<=n; i++)
{
    if (list[euler[i]] == null) 
        list[euler[i]] = new ArrayList<Integer>(brr[euler[i]].length);
    list[euler[i]].add(i);
}
for(int i=n; i>=6; i--)
{
    for(int j=euler[i]+2; j<i; j+=2)
    {
        if(list[j]==null) continue;
        for(int k=list[j].size()-1; k>=0 && (int)list[j].get(k)>i ; k--)
        {
            arr[i]+=1+arr[(int) list[j].get(k)]; arr[i]%=100000000;
        }
    }
}

并注意到一些奇怪的事情.显然,如果我用相同数组上的函数替换ArrayList上的函数,代码运行得更快(从83秒到27秒).那是:

Object[] x;
for(int i=n; i>=6; i--)
{
    for(int j=euler[i]+2; j<i; j+=2)
    {
        if(list[j]==null) continue;
        x=list[j].toArray();
        for(int …