用递归函数和栈逆序一个栈

import java.util.Scanner;
import java.util.Stack;

public class Main{

    // 将stack的栈底元素移除并返回
    public static int getAndRemoveLastElement(Stack<Integer> stack){
        int result = stack.pop();
        if (stack.isEmpty()){
            return result;
        } else {
            int last = getAndRemoveLastElement(stack);
            stack.push(result);
            return last;
        }
    }

    // 逆序一个栈
    public static void reverse(Stack<Integer> stack) {
        if (stack.isEmpty()) {
            return;
        }
        int i = getAndRemoveLastElement(stack);
        reverse(stack);
        stack.push(i);
    }

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        // 迷惑行为：本题的输入是入栈的反顺序，因此借助stackPlus将输入逆序
        Stack<Integer> stackInt = new Stack<>();
        Stack<Integer> stackPlus = new Stack<>();
        while (sc.hasNextInt()){
            int N = sc.nextInt();
            for (int i = 0; i < N; i++){
                stackPlus.push(sc.nextInt());
            }
            while (!stackPlus.isEmpty()){
                stackInt.push(stackPlus.pop());
            }
            reverse(stackInt);
            while (!stackInt.isEmpty()){
                System.out.print(stackInt.pop() + " ");
            }
        }
    }
}

void reverse_print(int ptr, int n, int arr[]){
    if(ptr < n){
        reverse_print(ptr+1, n, arr);
        printf("%d ", arr[ptr]);
    } else{
        return;
    }
}


int main(){
    int n;
    scanf("%d", &n);
    int arr[n];
    for(int i = 0; i < n; i++){
        cin >> arr[i];
    }
    reverse_print(0, n, arr);

    return EXIT_SUCCESS;
}

#include <stdio.h>
#include <malloc.h>
#include <stdbool.h>

typedef struct {
    int *data;
    int top;
} stack;

stack *new_stack(int cap);

void push(stack *st, int val);

int pop(stack *st);

bool is_empty(stack *st);

void destroy_stack(stack *st);

int remove_bottom(stack *st);

void reverse_stack(stack *st);

int main(void) {
    int n, x;
    scanf("%d", &n);
    stack *st = new_stack(n);
    for (int i = 0; i < n; i++) {
        scanf("%d", &x);
        push(st, x);
    }
    reverse_stack(st);
    while (!is_empty(st)) {
        x = pop(st);
        printf("%d", x);
        if (!is_empty(st))
            printf(" ");
    }
    printf("\n");
    destroy_stack(st);
    return 0;
}

int remove_bottom(stack *st) {
    int x = pop(st);
    if (is_empty(st)) {
        return x;
    }
    int next = remove_bottom(st);
    push(st, x);
    return next;
}

void reverse_stack(stack *st) {
    if (is_empty(st)) return;
    int bottom = remove_bottom(st);
    reverse_stack(st);
    push(st, bottom);
}

stack *new_stack(int cap) {
    stack *st = (stack *) malloc(sizeof(stack));
    st->data = (int *) malloc(sizeof(int) * cap);
    st->top = -1;
    return st;
}

void push(stack *st, int val) {
    st->data[++st->top] = val;
}

int pop(stack *st) {
    return st->data[st->top--];
}

bool is_empty(stack *st) {
    return st->top == -1;
}

void destroy_stack(stack *st) {
    free(st->data);
    free(st);
}

import java.util.Stack;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.IOException;
public class Main{
    private Stack<Integer> myStack;
    public Main(){
        this.myStack = new Stack<>();
    }
    public static void main(String[] args) throws IOException{
        BufferedReader sc = new BufferedReader(new InputStreamReader(System.in));
        int num = Integer.parseInt(sc.readLine());
        String[] inputData = sc.readLine().split(" ");
        Main m = new Main();
        for(int i=0;i<num;i++){
            m.myStack.push(Integer.parseInt(inputData[num-1-i])); 
        }
        m.reverse(m.myStack);
        m.print(m.myStack);

    }
    
    public int getandRemoveLast(Stack<Integer> stack){
        int result = stack.pop();
        if(stack.isEmpty()){
            return result;
        }
        else{
            int last = getandRemoveLast(stack);
            stack.push(result);
            return last;
        }
    }
    
    public void reverse(Stack<Integer> stack){
        if(stack.isEmpty()){
            return;
        }
        else{
            int i = getandRemoveLast(stack);
            reverse(stack);
            stack.push(i);
        }     
    }
    
    public void print(Stack<Integer>stack){
        if(stack.isEmpty()){
            return;
        }
        else{
            
            if(stack.size()==1){
                System.out.print(stack.pop());
            }
            else{
                System.out.print(stack.pop()+" ");
            }
            print(stack);
        }
    }

}

    private void reverse(Deque<Integer> stack){
        if(stack.isEmpty()){
            return;
        }
        int temp = stack.pop();
        reverse(stack);
        stack.push(temp);
    }

#include <bits/stdc++.h>
using namespace std;

void F(stack<int> S){
    cout<<S.top()<<" ";
    S.pop();
    if(!S.empty())
        F(S);
}

int main(){
    stack<int> S;
    int n, x;
    cin>>n;
    for(int i=0;i<n;i++){
        cin>>x;
        S.push(x);
    }
    F(S);
    return 0;
}

import java.util.*;

public class Main {
	public static void main(String[] args) {
		Scanner scanner = new Scanner(System.in);
		int n = scanner.nextInt();
		Stack<Integer> stack = new Stack<>();
		int[] arr = new int[n];
		for(int i=0;i<n;i++) {
			arr[i] = scanner.nextInt();
		}
		for(int i=n-1;i>=0;i--) {
			stack.push(arr[i]);
		}
		
		reverse(stack);
		
		for(int i=0;i<n;i++) {
			System.out.print(stack.pop() + " ");
		}
	}
	
	
	private static int getAndRemoveLastEle(Stack<Integer> stack) {
		int val = stack.pop();
		if(stack.isEmpty()) {
			return val;
		}else {
			int res = getAndRemoveLastEle(stack);
			stack.push(val);
			return res;
		}
	}
	
	private static void reverse(Stack<Integer> stack) {
		if(stack.isEmpty()) {
			return;
		}
		
		int lastEle = getAndRemoveLastEle(stack);
		reverse(stack);
		stack.push(lastEle);
	}
}

#include<bits/stdc++.h>
using namespace std;
stack<int>s,t;
void func()
{
    int m=s.top();
    s.pop();
    cout<<m<<" ";
    if(!s.empty())
        func();
}
int main()
{
    int n,x;
    cin>>n;
    for(int i=0;i<n;i++)
    {
        cin>>x;
        s.push(x);
    }
    func();
    return 0;
}

#include <algorithm>
#include <stack>
#include <vector>
using namespace std;

int popBottom(stack<int>& sta)
{
	int top = sta.top();
	sta.pop();
	if (sta.empty())return top;
	int down = popBottom(sta);
	sta.push(top);
	return down;
}
void reverseSta(stack<int>&sta)
{
	if (sta.size() == 1)return;
	int bottom = popBottom(sta);
	reverseSta(sta);
	sta.push(bottom);
}

int main()
{
	int n;
	scanf("%d", &n);
	stack<int> sta;
	for (int i = 0; i < n; i++)
	{
		int tmp;
		scanf("%d", &tmp);
		sta.push(tmp);
	}
	//reverseSta(sta);
	while (!sta.empty())
	{
		int top = sta.top();
		sta.pop();
		printf("%d ", top);
	}
}

来一个python能全部跑通的版本

注意: python 的recursion有次数限制, 默认的是1000, 但此处的测试用例的最后一个输入了1500多个数字, 所以要改变默认的限制, 这里保险设置成了2000.

​
​
​import sys
# python has a recurision limitation
# default is 1000
sys.setrecursionlimit(2000)

def getLastRemove(stack): 

    res = stack.pop()
    if len(stack) == 0:
        return res
    last = getLastRemove(stack)
    stack.append(res)
    return last

def reverse(stack): 
    if len(stack) == 0:
        return None
    i = getLastRemove(stack)
    reverse(stack)
    stack.append(i)
    return None

stack = []
N = int(input())

a = input()
for i in a.split():
    stack.append(int(i))

reverse(stack)

s=""

for i in range(N):
    s+= str(stack.pop())
    if i < N-1:
        s+= " "
print(s)

const readline = require("readline");

const rl = readline.createInterface({
    input: process.stdin,
    output: process.stdout,
});
rl.on("line", function (line) {
    const tokens = line.split(" ");
    if (tokens.length < 2) {
        return
    }
    const list = tokens.map(Number)
    const que = []
    list.forEach(e => {
        f1(que, e)
    })
    let res = ''
    while (que.length) {
        res += que.pop() + ' '
    }
    console.log(res)
});
function f1(que, t) {
    if (que.length < 1) {
        que.push(t)
        return
    }
    const v = que.pop()
    f1(que, t)
    que.push(v)
}