java自己写顺序栈实现 假设栈的输入序列为1、2、3、...、n，设计算法求出所有可能的出栈序列.

以下是Java的顺序栈实现，包括一个用于求解所有可能的出栈序列的算法：

import java.util.ArrayList;
import java.util.List;
import java.util.Stack;

public class SequenceStack {

    private static final int MAX_SIZE = 100; // 栈的最大容量
    private int[] stack; // 存储元素的数组
    private int top; // 栈顶指针

    public SequenceStack() {
        stack = new int[MAX_SIZE];
        top = -1;
    }

    // 将元素压入栈顶
    public void push(int element) {
        if (top == MAX_SIZE - 1) {
            throw new RuntimeException("Stack overflow");
        }
        stack[++top] = element;
    }

    // 返回栈顶元素，并将其弹出栈
    public int pop() {
        if (isEmpty()) {
            throw new RuntimeException("Stack is empty");
        }
        return stack[top--];
    }

    // 判断栈是否为空
    public boolean isEmpty() {
        return top == -1;
    }

    // 求解所有可能的出栈序列
    public List<List<Integer>> getAllPopSequences(int n) {
        List<List<Integer>> result = new ArrayList<>();
        Stack<Integer> stack = new Stack<>();
        getAllPopSequencesHelper(n, stack, result, new ArrayList<>());
        return result;
    }

    private void getAllPopSequencesHelper(int n, Stack<Integer> stack, 
                                          List<List<Integer>> result, List<Integer> sequence) {
        if (n == 0 && stack.isEmpty()) {
            result.add(new ArrayList<>(sequence));
        } else {
            if (!stack.isEmpty()) {
                int element = stack.pop();
                sequence.add(element);
                getAllPopSequencesHelper(n, stack, result, sequence);
                sequence.remove(sequence.size() - 1);
                stack.push(element);
            }
            if (n > 0) {
                int element = n--;
                stack.push(element);
                getAllPopSequencesHelper(n, stack, result, sequence);
                stack.pop();
                n++;
            }
        }
    }

    public static void main(String[] args) {
        SequenceStack stack = new SequenceStack();
        List<List<Integer>> result = stack.getAllPopSequences(3);
        System.out.println(result);
    }

}

该算法使用递归实现，核心思想是将所有可能的出栈序列分解为一系列子问题。对于每个子问题，我们可以尝试两个操作：

1. 将栈顶元素弹出。
2. 将下一个元素压入栈中。

我们可以按照这两个操作的顺序依次尝试，直到所有元素都被弹出并且栈为空。在过程中，我们需要记录已经弹出的元素序列以及当前栈中的元素。如果一个操作无法进行，我们就尝试另一个操作，直到所有情况都被尝试过。最终，所有可能的出栈序列都被记录在一个列表中返回。