题目描述：
一个栈依次压入1,2,3,4,5，那么从栈顶到栈底分别为5,4,3,2,1。将这个栈转置后，从栈顶到栈底为1,2,3,4,5，也就是实现栈中元素的逆序，但是只能用递归函数来实现，不能用其他数据结构。
输入描述
输入数据第一行一个整数N为栈中元素的个数。
接下来一行N个整数Xi表示从栈顶依次到栈底的每个元素。
输出描述
输出一行表示栈中元素逆序后的每个元素
示例1
输入
5
1 2 3 4 5
输出
5 4 3 2 1
解题思路
①每次从原来的栈中弹出栈底元素，之后可以用另一个栈来接收这些元素，原来的栈为空之后，再把新栈中的元素弹出到原栈
②每次从原来的栈中弹出栈底元素，之后可以用递归来缓收这些元素，因为递归本身也是基于栈
牛客通过的标准输入输出格式解题
注意类名是Main。
连包都要自己手动敲的吗？ 用 import java.util.*解决80%的问题？
//import java.util.Stack;
//import java.io.BufferedReader;
//import java.io.InputStreamReader;
//import java.util.Scanner;
import java.util.*;
public class Main {
public static void main(String[] args) {
Stack<Integer>stack=new Stack<Integer>();
// BufferedReader scanner = new BufferedReader(new InputStreamReader(System.in));
// String str = scanner.readLine();
// String str2=scannernextLine
Scanner sc = new Scanner(System.in);
String str2 = sc.nextLine().toString();
String str = sc.nextLine().toString();
int[] dis = getIntArr(str);
for(int i=dis.length-1;i>=0;i--)
{
stack.push(dis[i]);
}
reverseStack(stack);
while(!stack.empty())//遍历栈
{
System.out.print(stack.pop()+" ");
}
}
static int getAndRemoveBottom(Stack<Integer>stack)//每调用一次得到栈底元素并弹出栈底元素
{
int result= stack.pop();//取出并弹出当前栈的栈顶元素
if(stack.empty())
{
return result;//如果弹出一个元素后栈为空，说明栈中只有一个元素，就返回result
}
else
{
int Bottom=getAndRemoveBottom(stack);//开始递归了，这里会一直递，直到栈为空才会归
//也就是说弹出了最后一个元素，才会继续执行后面的代码（归）
/*
归
*/
stack.push(result);//前面递的过程一依次弹出栈顶元素，现在我们需要把除了原栈底元素压栈
//注意压栈的顺序，在归的过程中，是后弹出的元素先压栈
return Bottom;//最后一个内层递归结束，把最内层的Botttom一层一层地传到顶层，因为返回之后，才能继续push压栈
//才能保证假设原来是1,2,3，处理之后栈变为1,2
}
}
/*
每层递归取出栈底的元素并缓存到变量中，直到栈空
然后逆向将每层变量压入栈，最后实现原栈数据的逆序
*/
static void reverseStack(Stack<Integer>stack)
{
if(stack.empty())
{
return ;//我们本身函数就是定义的void,return只是为了结束内层递归
}
int Bottom=getAndRemoveBottom(stack);//每一次返回栈底元素
reverseStack(stack);
stack.push(Bottom);//压入接收到的元素，注意，在归的过程中，最后接收到的元素，最先压入栈
}
static int[] getIntArr(String str){
String[] arr = str.split(" ");
int[] b = new int[arr.length];
for(int j = 0; j<b.length;j++) {
b[j] = Integer.parseInt(arr[j]);
}
return b;
}
}
只用递归，不使用额外栈
import java.util.Stack;
public class recur {
public static void main(String[] args) {
Stack<Integer>stack=new Stack<Integer>();
stack.push(1);
stack.push(2);
stack.push(3);
stack.push(4);
stack.push(5);
reverseStack(stack);
while(!stack.empty())//遍历栈
{
System.out.println(stack.pop());
}
}
static int getAndRemoveBottom(Stack<Integer>stack)//每调用一次得到栈底元素并弹出栈底元素
{
int result= stack.pop();//取出并弹出当前栈的栈顶元素
if(stack.empty())
{
return result;//如果弹出一个元素后栈为空，说明栈中只有一个元素，就返回result
}
else
{
int Bottom=getAndRemoveBottom(stack);//开始递归了，这里会一直递，直到栈为空才会归
//也就是说弹出了最后一个元素，才会继续执行后面的代码（归）
/*
归
*/
stack.push(result);//前面递的过程一依次弹出栈顶元素，现在我们需要把除了原栈底元素压栈
//注意压栈的顺序，在归的过程中，是后弹出的元素先压栈
return Bottom;//最后一个内层递归结束，把最内层的Botttom一层一层地传到顶层，因为返回之后，才能继续push压栈
//才能保证假设原来是1,2,3，处理之后栈变为1,2
}
}
/*
每层递归取出栈底的元素并缓存到变量中，直到栈空
然后逆向将每层变量压入栈，最后实现原栈数据的逆序
*/
static void reverseStack(Stack<Integer>stack)
{
if(stack.empty())
{
return ;//我们本身函数就是定义的void,return只是为了结束内层递归
}
int Bottom=getAndRemoveBottom(stack);//每一次返回栈底元素
reverseStack(stack);
stack.push(Bottom);//压入接收到的元素，注意，在归的过程中，最后接收到的元素，最先压入栈
}
}
getAndRemoveBottom
reverseStack
递归+额外栈
getAndRemoveBottom函数与上文相同
static void reverseStack(Stack<Integer>stack)
{
Stack<Integer>stack1=new Stack<Integer>();
// 取出栈底的元素放到额外栈中，直到栈空
while(!stack.empty())
{
stack1.push(getAndRemoveBottom(stack)) ;
}
//取出栈顶的元素放到原栈中，直到栈空
while(!stack1.empty())
{
stack.push(stack1.pop());
}
}