递归Java堆栈

我正在研究递归，在这种情况下。。。我需要对一个堆栈的所有值求和。 我有两个功能，但只处理10000条记录。我至少需要一百万。请帮帮我

代码：

public static void main(String[] args) {
    Recursion r = new Recursion();
    Stack<Integer> stack = new Stack();
    Random rnd = new Random();
    int stack_size = 10000;
    for (int i = 0; i < stack_size; i++) {
        stack.push(rnd.nextInt(10 - 1));
    }
    int s = r.stack2(stack, 0);
    //int s = r.stack1(stack, stack_size, 0, 0);
    System.out.println("Sum = " + s);
}

public int stack2(Stack<Integer> stack, int sum) {
    if (stack.size() > 1) {
        sum += (stack.get(0) + stack.get(1));
        stack.remove(stack.get(0));
        stack.remove(stack.get(0));
        return stack2(stack, sum);
    } else {
        return sum;
    }
}

public int stack1(Stack<Integer> stack, int size, int i, int sum) {
    if (i < size) {
        i++;
        sum = sum + stack.get(i - 1);
        return stack1(stack, size, i, sum);
    } else {
        return sum;
    }
}

publicstaticvoidmain（字符串[]args）{
递归r=新的递归（）；
堆栈=新堆栈（）；
随机rnd=新随机（）；
int stack_size=10000；
对于（int i=0；i1）{
sum+=（stack.get（0）+stack.get（1））；
stack.remove（stack.get（0））；
stack.remove（stack.get（0））；
返回stack2（stack，sum）；
}否则{
回报金额；
}
}
公共整数堆栈1（堆栈堆栈、整数大小、整数i、整数和）{
如果（i<尺寸）{
i++；
sum=sum+stack.get（i-1）；
返回堆栈1（堆栈、大小、i、总和）；
}否则{
回报金额；
}
}

如果堆栈大小很大，不要使用递归。您将得到

java.lang.StackOverflowerError

。您可以使用

while

循环计算如下所示的总和：

public int stack2(Stack<Integer> stack) {
    int sum = 0;
    while (!stack.isEmpty()) {
        sum += stack.pop();
    }

    return sum; 
}

public int stack2（堆栈）{
整数和=0；
而（！stack.isEmpty（））{
sum+=stack.pop（）；
}
回报金额；
}

只是想添加这个。虽然用迭代的方法解决上述问题是一种较好的推荐方法

我们还有另一种解决办法。一种方法是增加JVM堆栈大小。另一种方法是在创建线程时以编程方式增加堆栈大小

在这里，我举一个例子来增加它的程序

public static void main(String[] args) throws InterruptedException {    

        Stack<Integer> stack = new Stack<Integer>();
        Random rnd = new Random();
        int stack_size = 10000;
        for (int i = 0; i < stack_size; i++) {
            stack.push(rnd.nextInt(10 - 1));
        }

        MyRunnable r = new MyRunnable(stack);

        Thread t = new Thread(null, r, "test-thread",  1 << 23);
        t.start();
        t.join();
        System.out.println(r.getSum());    
    }

publicstaticvoidmain（String[]args）抛出InterruptedException{
堆栈=新堆栈（）；
随机rnd=新随机（）；
int stack_size=10000；
对于（int i=0；iThread t=新线程（null，r，“test Thread”，1如果您必须有递归解决方案（当然是因为或任何其他要求），尽管如本文所述，它不是最优的，但您可以通过限制递归深度来实现。

其思想是限制递归深度（
recursion\u depth=1000；
），并逐段求和堆栈。

这样，您可以对任意大小的堆栈求和。在下面的示例中，大小为1M（
stack\u size=1000000；
）：

import java.util.Random；
导入java.util.Stack；
公共类堆栈递归{
私有最终静态整数堆栈大小=1000000；
private final static int recursion_DEPTH=1000；//递归深度的限制
公共静态void main（字符串[]args）{
StackRecursionSum r=新的StackRecursionSum（）；
堆栈=新堆栈（）；
随机rnd=新随机（）；
对于（int i=0；i0）和&！stack.isEmpty（））{
maxNumberOfElementsToSum--；
sum+=stack.pop（）；//从堆栈中删除最后一个元素并添加到sum
返回sumStack（堆栈，maxNumberOfElementsToSum，总和）；
}否则{
回报金额；
}
}
}

请注意，在递归运行结束时，堆栈是空的。
如果这是不可接受的，您可以始终在副本上进行求和：

    Stack<Integer> stackCopy = new Stack<>();
    stackCopy.addAll(stack);

Stack stackCopy=new Stack（）；
stackCopy.addAll（stack）；
您遇到的错误是什么？100万深度的递归很可能会遇到堆栈溢出，除非您有非常大的内存量。请注意，任何递归方法都可以重新分解为使用单个循环的方法。线程“main”中出现异常java.lang.StackOverflowerRorror在这种情况下，什么是最好的递归函数？@FredKYou应该使用
Stack
的
pop
方法，而不是奇怪的索引。
import java.util.Random;
import java.util.Stack;

public class StackRecursionSum  {

    private final static int STACK_SIZE = 1000000;
    private final static int RECURRSION_DEPTH = 1000; //limit of the recursion depth 

    public static void main(String[] args) {

        StackRecursionSum r = new StackRecursionSum();

        Stack<Integer> stack = new Stack<>();
        Random rnd = new Random();

        for (int i = 0; i < STACK_SIZE; i++) {
            stack.push(rnd.nextInt(10 - 1));
        }

        int sumForTesting =0;
        for (int i = 0; i < STACK_SIZE; i++) {
             sumForTesting += stack.get(i);
        }

        int stackSum = 0;
        while(! stack.isEmpty()) {

            stackSum += r.sumStack(stack, RECURRSION_DEPTH, 0);
        }

        //output
        System.out.println("Stack sum is = " + stackSum);

        //test 
        if(! stack.isEmpty()) {

            System.out.println("Error: stack is not empty. Recurssion did not end properly");
        }else if (stackSum != sumForTesting){

            System.out.println("Error: wrong test sum. Should be "+ sumForTesting);
        }else {
            System.out.println("************** All ok ");
        }
    }

    private int sumStack(Stack<Integer> stack, int maxNumberOfElementsToSum,  int sum) {

        if ((maxNumberOfElementsToSum > 0) && ! stack.isEmpty()) {

            maxNumberOfElementsToSum --;
            sum += stack.pop(); //remove last element from stack and add to sum

            return sumStack(stack, maxNumberOfElementsToSum , sum);

        } else {

            return sum;
        }
    }
}

    Stack<Integer> stackCopy = new Stack<>();
    stackCopy.addAll(stack);