递归输出所有出栈次序及卡塔兰数应用

Java-ArrayList模拟栈的操作，采用递归算法。代码如下：

import java.util.ArrayList;
import java.util.Scanner;

public class stackAll {
static int num=0;
public static void main(String[] args) {
Scanner scanner=new Scanner(System.in);
int n=scanner.nextInt();//输入元素个数
ArrayList<Integer> stackIn=new ArrayList<Integer>();
for(int i=n;i>0;i--)//初始化入栈队列
stackIn.add(i);

long start=System.currentTimeMillis();
stackOut(stackIn,new ArrayList<Integer>(),new ArrayList<Integer>());//调用递归
System.out.println(num);//最终完成后输出总数
System.out.println((System.currentTimeMillis()-start)/1000f);//时间消耗计算
}

public static void stackOut(ArrayList<Integer> stackIn,ArrayList<Integer> stack,ArrayList<Integer> stackOut){
if(stackIn.size()==0){//入栈队列是否空
if(stack.size()==0){//栈是否空
for(int x : stackOut)//如果说队列和栈都空，则说明出栈完成，输出出栈队列
System.out.print(x+" ");
System.out.println();
num++;//进行计数
}else{
stackOut.add(stack.get(stack.size()-1));//入栈队列空，栈非空，则只能出栈
stack.remove(stack.size()-1);
stackOut(stackIn,stack,new ArrayList<Integer>(stackOut));
}
}else{
if(stack.size()==0){//入栈队列非空，栈空，则入栈
stack.add(stackIn.get(stackIn.size()-1));
stackIn.remove(stackIn.size()-1);
stackOut(stackIn,stack,new ArrayList<Integer>(stackOut));
}else{
ArrayList<Integer> stack_copy=new ArrayList<Integer>(stack);//因为下面分两种情况进行回调函数，所以此处将数据复制一份
ArrayList<Integer> stackIn_copy=new ArrayList<Integer>(stackIn);

stack_copy.add(stackIn_copy.get(stackIn_copy.size()-1));//只入栈
stackIn_copy.remove(stackIn_copy.size()-1);
stackOut(stackIn_copy,stack_copy,new ArrayList<Integer>(stackOut));

stackOut.add(stack.get(stack.size()-1));//只出栈
stack.remove(stack.size()-1);
stackOut(stackIn,stack,new ArrayList<Integer>(stackOut));
}
}
}
}

计算超过14个元素的栈的出栈顺序，时间就开始很长了，每增加1，时间几何级数增长。

其实出栈次序的所有可能总数就是卡塔兰数，求卡塔兰数几乎不需要时间，非常快，但是卡特兰数只能输出最终结果的总数，不能输出每一个出栈次序的具体数据，所以依情况而使用。

以下附卡塔兰数求解代码。

import java.util.Scanner;

public class Main {
public static void main(String[] args) {
System.out.println(h(new Scanner(System.in).nextLong()));
}
public static long h(long n){
if(n==1)
return 1;
else if(n==2)
return 2;
else
return h(n-1)*(4*n-2)/(n+1);
}
}