理解java中的递归堆栈

代码运行良好。只是我不明白。在递归部分有困难。在这部分：

chara=st.peek（）；圣普（）；在底部（x）插入_；圣普什（a）我的想法是，首先它将执行
chara=st.peek（）；st.pop（）
一直到阈值。然后执行
st.push（a）一次。因此，
a
将只分配一次值。显然这不是事实

对我来说，最困难的部分是
insert\u-at\u-bottom
方法
insert\u-at\u-bottom（x）
做什么？在
reverse
方法中
reverse（）
，
在底部（x）插入\u做什么

import java.util.Stack;
class Test {
    static Stack<Character> st = new Stack<>();
    static void insert_at_bottom(char x)
    {
        if(st.isEmpty()) st.push(x);
        else
        {char a = st.peek();
            st.pop();
            insert_at_bottom(x);
            st.push(a);
        }
    }
    
    static void reverse()
    {
        if(st.size() > 0)
        {           
            char x = st.peek();
            st.pop();
            reverse();
            insert_at_bottom(x);
        }
    }
    public static void main(String[] args)
    {   st.push('1'); st.push('2'); st.push('3'); st.push('4');     
        System.out.println("Original Stack");
        System.out.println(st);
        reverse();
        System.out.println("Reversed Stack");
        System.out.println(st); }}

import java.util.Stack；
课堂测试{
静态堆栈st=新堆栈（）；
在底部插入静态空白（字符x）
{
如果（st.isEmpty（））st.push（x）；
其他的
{char a=st.peek（）；
圣普（）；
在底部（x）插入_；
圣普什（a）；
}
}
静态无效反向（）
{
如果（标准尺寸（）>0）
{           
char x=st.peek（）；
圣普（）；
反向（）；
在底部（x）插入_；
}
}
公共静态void main（字符串[]args）
{st.push（'1'）；st.push（'2'）；st.push（'3'）；st.push（'4'）；
System.out.println（“原始堆栈”）；
系统输出打印LN（st）；
反向（）；
System.out.println（“反向堆栈”）；
System.out.println（st）；}
要了解方法的功能，必须了解
堆栈是什么。
堆栈
就像一堆板：您只能将板放在堆栈顶部，或从顶部取回板。否则，堆栈将崩溃

如果你想在盘子的底部加一块盘子，你必须先把所有盘子都取下来。简单的方法如下：当堆栈上有一个盘子时，你把它取下来放在一边。如果堆栈是空的，那么你可以把你的新盘子放在堆栈的底部。然后你必须把所有的盘子放回新的底板上

在
insert\u底部
中的操作与此完全相同，但使用递归方法：当堆栈中有一个
char
时，即它不是空的，您将顶部的
char
-标记为
a
-放在一边，然后再次尝试将
x
放在底部。如果堆栈不是空的，则重新执行该操作。一旦到达堆栈的底部，就可以将
x
放在那里，并开始按与以前相同的顺序推送所有其他
char
s

reverse
方法使用几乎相同的过程，但有一点扭曲：取顶部的
char
，放在一边，取第二个顶部的
char
，放在一边。。。当您使用最后一个
字符时，可以将其放在堆栈的底部。然后将前面的第二个底部
char
放在堆栈的底部。。。然后返回到之前放在最后底部的顶部
char
。然后，所有堆栈都已反转。
首先，我们将对堆栈使用
[]
符号。空堆栈将被表示为
[]
。当我们按下或弹出一个元素时，我们将在左侧执行此操作。例如，如果我们以
[1,2,3]
和pop开始，我们将剩下
[2,3]
，pop将返回
1
。如果我们从
[1,2,3]
开始，然后按
0
，我们将剩下
[0,1,2,3]

insert\u at_bottom
的唯一目的是使我们能够将元素推式附加到堆栈的右侧，而不是堆栈的左侧

那么，我们如何在堆栈的右侧而不是左侧插入某些内容（假设我们希望插入
x
）？我们考虑两种不同的情况：

堆栈为空：即，
st=[]
在这种情况下，向右推和向左推是相同的，所以我们只调用
st.push（x）
，现在有
st=[x]

堆栈是非空的：例如，堆栈是['1'，'2'，'3']
首先，我们从堆栈中弹出
'1'
。现在我们有了
st=['2'，'3']


然后，我们通过递归调用将x推到
st
的右侧。这给了我们
st=['2'，'3'，x]


最后，我们将
'1'
推回到堆栈上。这给了我们
st=['1'，'2'，'3'，x]
。如您所见，我们已成功地在
st
的最右侧位置插入
x

这就是
在底部插入\u
的工作原理

现在，
反向
是如何工作的？我们再次考虑两个不同的情况。
堆栈是空的；也就是说，
st=[]
在这种情况下，我们不需要做任何事情来反转
st

堆栈是非空的；我们将以
st=['1'，'2'，'3']
为例
首先，我们从堆栈中弹出
'1'
，留下
st=['2'，'3']


然后，我们反转
st
，留下
st=['3'，'2']


最后，我们通过调用
insert_bottom（'1'）
，在
st
的右侧插入
'1'
，留下
st=['3'，'2'，'1']

正如您所看到的，我们已经成功地逆转了
st
这个链接看起来非常好。正如评论员所说：试图理解代码，但就是无法理解。“你能简单地一步一步地指导我吗[1,2]顺便说一句，你不应该使用
st.size（）>0
，而应该使用
！st.isEmpty（）
。根据
堆栈的实现情况，查找堆栈的大小可能比检查堆栈是否为空慢得多。而且，检查堆栈大小绝不可能比检查清空慢得多