Leetcode 946. Validate Stack Sequences

Given two sequences pushed and popped with distinct values, return
true if and only if this could have been the result of a sequence of
push and pop operations on an initially empty stack.

Example 1:

Input: pushed = [1,2,3,4,5], popped = [4,5,3,2,1] Output: true
Explanation: We might do the following sequence: push(1), push(2),
push(3), push(4), pop() -> 4, push(5), pop() -> 5, pop() -> 3, pop()
-> 2, pop() -> 1 Example 2:

Input: pushed = [1,2,3,4,5], popped = [4,3,5,1,2] Output: false
Explanation: 1 cannot be popped before 2.

Note:

0 <= pushed.length == popped.length <= 1000 0 <= pushed[i], popped[i]
< 1000 pushed is a permutation of popped. pushed and popped have
distinct values.

思路：

pushed 是入栈顺序，popped是出栈顺序，用一个list模拟栈，遍历pushed中的每一个数，把它入栈；如果栈顶元素满足出栈条件，则出栈；最后判断栈是否为空；

以题目为例：
pushed【1、2、3、4、5】
popped【4、5、3、2、1】

从左至右遍历pushed中的每一个元素，

• 把“1”入栈，此时栈中的元素只有一个“1”，因为“1”不等于popped中的第一个元素“4”，说明“1”不是出栈元素，继续遍历；

• 把“2”入栈，此时栈中有“2”、“1”，因为“2”不等于“4”，继续遍历；

• 把“3”入栈，此时栈中有“3”、“2”、“1”，因为“3”不等于“4”，继续遍历；

• 把“4”入栈，此时栈中有“4”、“3”、“2”、“1”，因为“4”等于popped中的“4”，则“4”出栈，栈中还剩下“3”、“2”、“1”，然后判断当前栈顶元素“3”不等于popped中的“5”，继续遍历；

• 把“5”入栈，此时栈中有“5”、“3”、“2”、“1”，因为“5”等于popped中的“5”，则“5”出栈，栈中还剩下“3”、“2”、“1”；

• 因为“3”等于popped中的“3”，则“3”出栈；

• 因为“2”等于popped中的“2”，则“2”出栈；

• 因为“1”等于popped中的“1”，则“1”出栈；

此时栈为空，返回true

class Solution {
    public boolean validateStackSequences(int[] pushed, int[] popped) {
        LinkedList<Integer> list = new LinkedList<>();
        int j = 0;
        for (int i : pushed) {
            list.add(i);
            while (!list.isEmpty() && list.getLast() == popped[j]) {
                list.removeLast();
                j++;
            }
        }
        while(!list.isEmpty() && list.getLast() == popped[j++]) {
            list.removeLast();
        }
        return list.isEmpty();
    }
}

ps: 也可以用Stack来作为栈，但是可能要比list要慢一点，7ms是用list模拟的结果，16ms是用Stack的结果