栈题目：验证栈序列

题目

标题和出处

标题：验证栈序列

出处：946. 验证栈序列

难度

5 级

题目描述

要求

给定 $\text{pushed}$ 和 $\text{popped}$ 两个序列，每个序列中的值都不重复，只有当它们可能是在最初空栈上进行的推入和弹出操作序列的结果时，返回 $\text{true}$；否则，返回 $\text{false}$。

示例

示例 1：

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

示例 2：

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

数据范围

• $\text{1}\le \text{pushed.length}\le \text{1000}$
• $\text{0}\le \text{pushed[i]}\le \text{1000}$
• $\text{pushed}$ 的所有元素互不相同
• $\text{popped.length}=\text{pushed.length}$
• $\text{popped}$ 是 $\text{pushed}$ 的一个排列

解法

思路和算法

由于 $\text{pushed}$ 的所有元素互不相同，因此在任意时刻，栈内不可能出现两个相等的元素。

元素按照 $\text{pushed}$ 中的顺序依次入栈，按照 $\text{popped}$ 中的顺序依次出栈，出栈操作可能发生在任意时刻。由于只有当一个元素已经入栈且位于栈顶时，该元素才可能出栈，因此出栈操作发生的时刻一定是栈顶元素等于 $\text{popped}$ 中的当前元素的时刻。由此可以模拟入栈和出栈的操作，判断给定的 $\text{pushed}$ 和 $\text{popped}$ 是否为有效的栈操作序列。

初始时，$\text{pushed}$ 和 $\text{popped}$ 的下标都是 $0$。模拟的做法如下。

1. 将 $\text{pushed}$ 的当前元素入栈，并将 $\text{pushed}$ 的下标加 $1$。

2. 判断栈顶元素是否等于 $\text{popped}$ 的当前元素：

   • 如果相等，则将栈顶元素出栈，并将 $\text{popped}$ 的下标加 $1$，重复该过程直到栈为空或者栈顶元素不等于 $\text{popped}$ 的当前元素；

   • 如果不相等，则回到第 1 步。

重复上述操作，直到 $\text{pushed}$ 和 $\text{popped}$ 当中至少有一个数组的下标超出数组的下标范围。

如果 $\text{popped}$ 的下标超出范围，则全部元素都已经出栈，由于每个元素都必须在入栈之后才能出栈，因此全部元素都一定有过入栈，即 $\text{pushed}$ 的元素全部遍历过，可知 $\text{pushed}$ 的下标也超出范围。因此不存在 $\text{popped}$ 的下标超出范围时 $\text{pushed}$ 的下标不超出范围的情况，即上述操作结束时，$\text{pushed}$ 的下标一定超出范围，即 $\text{pushed}$ 的元素全部遍历过。

由于上述操作结束时，$\text{pushed}$ 的元素全部遍历过，因此其中的元素都一定有过入栈。由于 $\text{pushed}$ 和 $\text{popped}$ 的长度相同，对于有效的栈操作序列，入栈次数和出栈次数相同，最终结果是栈为空。因此当上述操作结束时，如果栈为空则返回 $\text{true}$，否则返回 $\text{false}$。

还有其他的依据可以判断是否为有效的栈操作系列。由于 $\text{popped}$ 的每个元素都出栈，因此对于有效的栈操作序列，当上述操作结束时，$\text{popped}$ 的下标一定超出下标范围。因此另一种判断方法是，当上述操作结束时，如果 $\text{popped}$ 的下标超出下标范围则返回 $\text{true}$，否则返回 $\text{false}$。

代码

class Solution {
    public boolean validateStackSequences(int[] pushed, int[] popped) {
        Deque<Integer> stack = new ArrayDeque<Integer>();
        int length = pushed.length;
        int pushIndex = 0, popIndex = 0;
        while (pushIndex < length && popIndex < length) {
            stack.push(pushed[pushIndex]);
            pushIndex++;
            while (!stack.isEmpty() && stack.peek() == popped[popIndex]) {
                stack.pop();
                popIndex++;
            }
        }
        return stack.isEmpty();
    }
}

复杂度分析

• 时间复杂度：$O(n)$，其中 $n$ 是数组 $\text{pushed}$ 和 $\text{popped}$ 的长度。需要遍历数组 $\text{pushed}$ 和 $\text{popped}$ 各一次，每个元素最多入栈和出栈各一次。

• 空间复杂度：$O(n)$，其中 $n$ 是数组 $\text{pushed}$ 和 $\text{popped}$ 的长度。空间复杂度主要取决于栈空间，栈内的元素个数为 $O(n)$。