入栈顺序为1234，求出所有的出栈顺序

对于一个栈来说，出栈序列必须满足以下条件：

1. 当前栈顶元素和出栈序列的第一个元素相同；
2. 如果当前栈顶元素和出栈序列的第一个元素不同，则从未进栈的元素中找一个和出栈序列的第一个元素相同的数进栈；
3. 如果从未进栈的元素中也找不到和出栈序列的第一个元素相同的数，则出栈序列不合法。

因此，我们可以采用回溯法来求解。具体的，我们从入栈序列中取出一个元素，将其压入栈中，然后递归处理剩余的元素。如果当前栈顶元素和出栈序列的第一个元素相同，那么我们将其出栈，并递归处理剩余的元素。如果当前栈顶元素和出栈序列的第一个元素不同，则从未进栈的元素中找一个和出栈序列的第一个元素相同的数进栈。如果从未进栈的元素中也找不到和出栈序列的第一个元素相同的数，则回溯到上一层，换一个数进来。

下面是具体的实现：

def backtrack(stack, nums, res):
    if not nums:
        res.append(stack[:])
        return
    
    # 将当前元素压入栈中
    stack.append(nums[0])
    backtrack(stack, nums[1:], res)
    stack.pop()
    
    # 从未入栈的元素中找到一个和出栈序列的第一个元素相同的数
    for i in range(1, len(nums)):
        if nums[i] == stack[-1]:
            stack.append(nums[i])
            backtrack(stack, nums[1:i] + nums[i+1:], res)
            stack.pop()
    
    return

def get_all_pop_orders(nums):
    if not nums:
        return []
    
    res = []
    stack = []
    backtrack(stack, nums, res)
    return res

使用示例：

>>> nums = [1, 2, 3, 4]
>>> res = get_all_pop_orders(nums)
>>> for seq in res:
...     print(seq)
...
[4, 3, 2, 1]
[3, 4, 2, 1]
[4, 2, 3, 1]
[2, 4, 3, 1]
[3, 2, 4, 1]
[2, 3, 4, 1]
[4, 3, 1, 2]
[3, 4, 1, 2]
[4, 1, 3, 2]
[1, 4, 3, 2]
[3, 1, 4, 2]
[1, 3, 4, 2]
[4, 2, 1, 3]
[2, 4, 1, 3]
[4, 1, 2, 3]
[1, 4, 2, 3]
[2, 1, 4, 3]
[1, 2, 4, 3]
[3, 2, 1, 4]
[2, 3, 1, 4]
[3, 1, 2, 4]
[1, 3, 2, 4]
[2, 1, 3, 4]
[1, 2, 3, 4]