Java 如何使我的函数是递归的？（爪哇）

我必须生成一个递归函数，它将接收一个“int”堆栈，并输出堆栈中元素的平方和。 这是我的

public int sum_sqr_rec(Stack<Integer> stk){
int sum = 0;
for (int i=0; i<stk.size(); i++){
sum += (stk.get(i) * stk.get(i));
}
return sum;
}

public int sum_sqr_rec（堆栈stk）{
整数和=0；
对于（int i=0；i递归函数，您需要确定的最重要的事情是何时终止它

第二个重要的考虑事项是当你终止它时返回的内容。当你开始添加数字时，你先从<代码>求和= 0 。从递归函数中，它应该计算数字的和，相同的值（即<代码> 0 < /代码>）。可以在终止时返回。类似地，从递归函数（应该返回数字的乘积）中，可以在终止时返回
1

import java.util.Stack;

public class Main {
    public static void main(String[] args) {
        Stack<Integer> stack = new Stack<Integer>();
        stack.add(2);
        stack.add(3);
        stack.add(4);
        stack.add(5);
        System.out.println(sum_sqr_rec(stack));
    }

    static int sum_sqr_rec(Stack<Integer> stk) {
        if (stk.isEmpty()) {
            return 0;
        }
        int n = stk.pop();
        return n * n + sum_sqr_rec(stk);
    }
}

对于递归函数，您需要确定的最重要的事情是何时终止它

第二个重要的考虑事项是当你终止它时返回的内容。当你开始添加数字时，你先从<代码>求和= 0 。从递归函数中，它应该计算数字的和，相同的值（即<代码> 0 < /代码>）。可以在终止时返回。类似地，从递归函数（应该返回数字的乘积）中，可以在终止时返回
1

import java.util.Stack;

public class Main {
    public static void main(String[] args) {
        Stack<Integer> stack = new Stack<Integer>();
        stack.add(2);
        stack.add(3);
        stack.add(4);
        stack.add(5);
        System.out.println(sum_sqr_rec(stack));
    }

    static int sum_sqr_rec(Stack<Integer> stk) {
        if (stk.isEmpty()) {
            return 0;
        }
        int n = stk.pop();
        return n * n + sum_sqr_rec(stk);
    }
}

可以像这样使用递归：

    public static void main(String[] args) {
        Stack<Integer> stack = new Stack<>();
        stack.add(2);
        stack.add(2);
        stack.add(4);
        stack.add(5);
        System.out.println(sum_sqr_rec(stack));
    }

    public static int sum_sqr_rec(Stack<Integer> stack) {
        if (stack.isEmpty())
            return 0;
        return stack.peek() * stack.pop() + sum_sqr_rec(stack);
    }

publicstaticvoidmain（字符串[]args）{
堆栈=新堆栈（）；
堆栈。添加（2）；
堆栈。添加（2）；
堆栈。添加（4）；
堆栈。添加（5）；
System.out.println（sum_sqr_rec（stack））；
}
公共静态整数和平方比记录（堆栈）{
if（stack.isEmpty（））
返回0；
返回stack.peek（）*stack.pop（）+sum_sqr_rec（stack）；
}
您可以像这样使用递归：

    public static void main(String[] args) {
        Stack<Integer> stack = new Stack<>();
        stack.add(2);
        stack.add(2);
        stack.add(4);
        stack.add(5);
        System.out.println(sum_sqr_rec(stack));
    }

    public static int sum_sqr_rec(Stack<Integer> stack) {
        if (stack.isEmpty())
            return 0;
        return stack.peek() * stack.pop() + sum_sqr_rec(stack);
    }

publicstaticvoidmain（字符串[]args）{
堆栈=新堆栈（）；
堆栈。添加（2）；
堆栈。添加（2）；
堆栈。添加（4）；
堆栈。添加（5）；
System.out.println（sum_sqr_rec（stack））；
}
公共静态整数和平方比记录（堆栈）{
if（stack.isEmpty（））
返回0；
返回stack.peek（）*stack.pop（）+sum_sqr_rec（stack）；
}
请注意，我使用的是Deque接口，而不是直接使用Stack类（文档中说它应该优先于Stack类使用）

public int recursive（Deque stk）{
if（stk.Empty（））{
返回0；
}
返回Math.pow（stack.pop（），2）+递归（stk）；
}
请注意，我使用的是Deque接口，而不是直接使用Stack类（文档中说它应该优先于Stack类使用）

public int recursive（Deque stk）{
if（stk.Empty（））{
返回0；
}
返回Math.pow（stack.pop（），2）+递归（stk）；
}
有很多方法可以做到这一点。但是如果您不想破坏堆栈，可以这样做。堆栈将在返回过程中恢复


弹出
n
。这会耗尽数字堆栈，并将
n
保留在本地调用堆栈中以供以后使用
元素的平方保存在
k

r
为最终理货进行初始化

一旦堆栈为空，只需将
n
推回
stk
并返回保存的平方和

结果如下

[2, 3, 4, 5]
54
[2, 3, 4, 5]

有很多方法可以做到这一点。但是如果你不想破坏堆栈，你可以这样做。堆栈会在返回过程中恢复


弹出
n
。这会耗尽数字堆栈，并将
n
保留在本地调用堆栈中以供以后使用
元素的平方保存在
k

r
为最终理货进行初始化

一旦堆栈为空，只需将
n
推回
stk
并返回保存的平方和

结果如下

[2, 3, 4, 5]
54
[2, 3, 4, 5]

if（stk.empty（））返回0；int i=stk.pop（）；返回i*i+sum_sqr_rec（stk）；
if（stk.empty（））返回0；int i=stk.pop（）；返回i*i+sum_sqr_rec（stk）；

[2, 3, 4, 5]
54
[2, 3, 4, 5]