剑指Offer面试题-31 栈的压入、弹出序列（栈、模拟）

题目描述

输入两个整数序列，第一个序列表示栈的压入顺序，请判断第二个序列是否为该栈的弹出顺序。假设压入栈的所有数字均不相等。例如，序列 {1,2,3,4,5} 是某栈的压栈序列，序列 {4,5,3,2,1} 是该压栈序列对应的一个弹出序列，但 {4,3,5,1,2} 就不可能是该压栈序列的弹出序列。

示例 1：

输入：pushed = [1,2,3,4,5], popped = [4,5,3,2,1]
输出：true
解释：我们可以按以下顺序执行：
push(1), push(2), push(3), push(4), pop() -> 4,
push(5), pop() -> 5, pop() -> 3, pop() -> 2, pop() -> 1

示例 2：

输入：pushed = [1,2,3,4,5], popped = [4,3,5,1,2]
输出：false
解释：1 不能在 2 之前弹出。

提示：

0 <= pushed.length == popped.length <= 1000
0 <= pushed[i], popped[i] < 1000
pushed 是 popped 的排列。

题解

思路就是根据出栈序列来模拟入栈出栈的过程，如果行得通就说明是合法的。

对于出栈序列中的一个值，如果这个值不在栈中，就应该将入栈序列中的值一个个压入栈，直到压入了一个和出栈序列相同的值。

对于题目描述中的例子，出栈序列的第一个是4，那么应该让入栈序列依次入栈，直到4入栈，即可停止。那么此时栈中的数据为[1, 2, 3, 4]。

然后模拟出栈过程，将4弹出，此时栈中的数据为[1, 2, 3]。

重复上面的操作，出栈序列第二个值为5，5也不在栈中，那么让入栈序列依次入栈，直到5入栈就停止。那么此时栈中的数据为[1, 2, 3, 5]。

然后模拟出栈过程，将5弹出，此时栈中的数据为[1, 2, 3]。

此时，出栈序列的下一个是3，检测到3在栈里面，那么就判断栈顶是否为3，如果是的，就出栈，并继续判断出栈序列。如果栈顶不是3，那么说明这个序列非法。

---

在上面的步骤中，频繁出现了判断某个值是否在栈中，那么可以使用哈希表来记录，能以$O(1)$的复杂度判断。但根据题目给出值的范围为[0, 1000]，所以可以使用数组来替代。

代码实现：

class Solution {
    public boolean validateStackSequences(int[] pushed, int[] popped) {
        int [] numInStack = new int[1000];
        Deque<Integer> stack = new ArrayDeque<>();

        int stackIndex = 0;
        for (int i = 0 ; i < popped.length ; i++)
        {
        	// 栈中没有目标值
            if (numInStack[popped[i]] == 0) {
            	// 循环入栈，直到栈中有目标值
                while (stackIndex < pushed.length)
                {
                    stack.offerLast(pushed[stackIndex]);
                    numInStack[pushed[stackIndex]] = 1;
                    stackIndex++;
                    // 如果栈中有了目标值，跳出循环
                    if (numInStack[popped[i]] == 1) {
                        break;
                    }
                }
            }
            // 判断栈顶是否为目标值，如果是，则弹出
            if (stack.size() > 0 && stack.peekLast() == popped[i]) {
                stack.pollLast();
                numInStack[popped[i]] = 0;
            } else {
                return false;
            }
        }
        return true;
    }
}

时间复杂度：$O(n)$
$n$为出栈/入栈序列长度，虽然是双重循环，但出栈序列和入栈序列都只需遍历一遍。

空间复杂度：$O(n)$
辅助栈最多需要填充整个长度为$n$的序列。