Java之根据入栈顺序是否能得到出栈顺序

前言

给出入栈顺序，匹配一个出栈顺序是否合法，即出栈入栈一定要满足先进后出的特定。

一、Java入栈、出栈

1、例题

输入两个整数序列，第一个序列表示栈的压入顺序，请判断第二个序列是否为该栈的弹出顺序。假设压入栈的所有数字均不相等。例如，序列 {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 之前弹出。

二、题解

A.纯正的模拟

思想）根据栈的特点后进先出和出栈序列，来模拟什么时候入栈和出栈，通过set来记录以前是否入栈过，再通过栈顶元素是否相等来模拟入栈和出栈。

public boolean validateStackSequences3(int[] pushed, int[] popped) {
        //map来记录是否被压入到前面出不来，用栈结构来模拟入栈出栈
        Set<Integer> mark = new HashSet<>();
        Deque<Integer> stack = new ArrayDeque<>();
        int i = 0, j = 0;
        //模拟
        while (j != popped.length) {
            if (stack.isEmpty() || i < pushed.length && stack.peek() != popped[j]) {
                stack.push(pushed[i]);
                mark.add(pushed[i]);
                i++;
            }
            if(stack.peek() == popped[j]){
                stack.pop();
                mark.remove(stack.peek());
                j++;
            }else if(mark.contains(popped[j]))
                return false;
        }
        return true;
    }

B.LinkedHashSet

用set来记录，linkedlist来模拟栈，将两个融合在一起就是LinkedHashSet。

public boolean validateStackSequences2(int[] pushed, int[] popped) {
        //map来记录是否被压入到前面出不来，用栈结构来模拟入栈出栈
        Set<Integer> mark = new LinkedHashSet<>();
        int i = 0, j = 0;
        //模拟
        while (j != popped.length) {
            if (pushed[i] == popped[j]) {
                i += i == pushed.length - 1 ? 0 : 1;
                j++;
            } else if (mark.isEmpty() || (int) mark.toArray()[mark.size() - 1] != popped[j] && !mark.contains(popped[j])) {
                mark.add(pushed[i]);
                i += i == pushed.length - 1 ? 0 : 1;
                ;
            } else if ((int) mark.toArray()[mark.size() - 1] != popped[j] && mark.contains(popped[j]))
                return false;
            else {
                mark.remove(popped[j]);
                j++;
            }
        }
        return true;
    }

C.利用CPU

上面的模拟，太过于刻板，有太多的if else if，这样的选择会使CPU利用率下降。CPU最擅长的就是计算，不用set记录一些元素是否入栈过。
思想）一旦不相等或栈空，就入栈元素；（不用管出栈序列元素是否在低端无法出栈）一旦相等就出栈然后再比较栈顶元素是否和下一个需出栈的元素相等。

public boolean validateStackSequences(int[] pushed, int[] popped) {
        //map来记录是否被压入到前面出不来，用栈结构来模拟入栈出栈
        Deque<Integer> stack = new ArrayDeque<>();
        int i = 0;
        //模拟
        for(int num : pushed){
            stack.push(num);
            while(!stack.isEmpty() && stack.peek() == popped[i]){
                stack.pop();
                i++;
            }
        }
        return stack.isEmpty();
    }

总结

1）刻板模拟，CPU利用率不高。
2）不用每次比较完是否相等都去判断一下该元素是否被压在低端而导致无法出栈。

参考文献

[1] Leetcode 原题
[2] Leetcode 解答