所有出栈顺序及其总数

算法设计与分析老师给了个练习题：

 

栈是一种重要的数据结构，其主要的操作包括入栈和出栈。请编写程序，对任意给定的n，输出1，2，…，n的所有出栈顺序及其总数。

     我用两种方法写了！第二种方法我写了好几天，自己的编程能力还不行啊！要多锻炼锻炼！还有总数应该用卡特兰数求的，我投机取巧了！各位大侠要是能帮忙改进就好了！

  algorithm1:

设计：先求出全排列，再判断是否为正确的出栈顺序！ 

分析：算法时间复杂度为O(n^3), 效率很低！空间复杂度为O(1);

/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
*/

/**
 *
 * @author Administrator
*/
import java.util.*;
publicclass stack_algorithm1 {
publicstaticint all;
publicstaticvoid main(String[] args) {
int total;
int [] stack;
        Scanner reader =new Scanner(System.in);
        total = reader.nextInt();
        stack =newint [total];
for (int i =0; i < stack.length; i++) {
            stack[i] = i+1;
            
        }
        ShowTruePop(stack,0,stack.length-1);
        System.out.println("Total: "+all);
    }
publicstaticvoid ShowTruePop(int [] stack,int start,int end){
int test [] =newint [stack.length];
if(start==end){//当只要求对数组中一个进行全排列时，只要就按该数组输出即可
for(int i=0;i<=end;i++){
                test[i] = stack[i];
            }
if (IsTruePop(test)) {
for (int i =0; i < test.length; i++) {
                    System.out.print(test[i]+"");
                    
                }
                System.out.println();
                all++;
            }
                
        }
else{//多个字母全排列
for(int i=start;i<=end;i++){
int temp=stack[start];//交换数组第一个元素与后续的元素
                stack[start]=stack[i];
                stack[i]=temp;
                
                ShowTruePop(stack,start+1,end);//后续元素递归全排列
                
                temp=stack[start];//将交换后的数组还原
                stack[start]=stack[i];
                stack[i]=temp;
            }
        
        }
    }
publicstaticboolean IsTruePop(int [] test){//判断是否为正确的出栈
for (int i =0; i < test.length-2; i++) {
for (int j = i+1; j < test.length-1; j++) {
for (int k = j+1; k < test.length; k++) {
if ((test[j] < test[k]) && (test[k] < test[i])) {
returnfalse;
                        
                    }
                    
                }
                
            }
            
        }
returntrue;
    }
}

 

  algorithm2： 

设计：1、若n=1那么就一种排列方式。2、n>1时先求出n-1的出栈顺序，再分开将n插入n-1之前，n-1之后和每一个n-1之后的每一个数！有点想数学归纳法的思想！

分析： 算法时间复杂度为O(c(n,2n)/（n+1))即为卡特兰数，效率很高。空间复杂度为O(c(n,2n)/（n+1))*n)占用空间比较大，是典型的以空间换时间！

/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
*/

/**
 *
 * @author Administrator
*/
import java.util.*;
public class stack_algorithm2 {
    public static void main(String[] args) {
        int total = 0;
        int [][] save = new int [300][];
        Scanner reader = new Scanner(System.in);
        int n = reader.nextInt();
        int stack[] = new int [n];
        for (int i = 0; i < stack.length; i++) {
            stack[i]=i+1;
            
        }
        for (int i = 0; i < 300; i++) {
            save[i] = new int [stack.length+1];
            
        }
        InnArr(stack,save);
        System.out.println("The result is: ");
        for (; save[total][0] != 0; total++) {
            for (int j = 0; j < save[total].length-2; j++) {
                System.out.print(save[total][j]+" ");
                
            }
            System.out.println(save[total][save[total].length-2]);
            
        }
        System.out.println("Total: "+total);
    }
    
    
    public static void InnArr(int [] stack,int [][]save){
        int k = 1;
        int p = 1;
        save[0][0] = stack[0];
        while(k<stack.length){
            p = inset(stack,save,k,p);
            k++;
        }
    }
    
    public static int inset(int [] stack,int [][] save,int k,int p){
        int f=p;
        for (int i = 0; i < p; i++) {
            for (int j = 0; j < k; j++) {
                if (save[i][j]==stack[k-1]) {
                    int temp [] = new int [save[i].length];
                    System.arraycopy(save[i], 0, temp, 0, save[i].length);
                    set(save[i],j+1,stack[k],temp);
                    set(save[f],j,stack[k],temp);
                    f++;
                    for (int m = j+2; m <= k; m++) {
                        set(save[f],m,stack[k],temp);
                        f++;
                        
                    }
                    break;
                }
                
            }
            
        }
        return  f;
    }
    
    public static void set(int [] save,int m,int k,int [] arr){
        System.arraycopy(arr, 0, save, 0, save.length);
        for (int i = save.length-2; i >= m; i--) {
            save[i+1]=save[i];
            
        }
        save[m]=k;
    }
}