剑指offer|栈的压入、弹出序列

【题目描述】
输入两个整数序列，第一个序列表示栈的压入顺序，请判断第二个序列是否可能为该栈的弹出顺序。假设压入栈的所有数字均不相等。例如序列1,2,3,4,5是某栈的压入顺序，序列4,5,3,2,1是该压栈序列对应的一个弹出序列，但4,3,5,1,2就不可能是该压栈序列的弹出序列。（注意：这两个序列的长度是相等的）

时间限制：1秒 空间限制：32768K 热度指数：319003
本题知识点： 栈

【解答思路】
法一： 对于第一个弹出元素popA[0]， 说明在其之前的元素都按照入栈顺序排列在栈里。找到其在pushA中的位置index，index之前的元素的弹出顺序是确定的，即pushA[index-1]一定比pushA[index-2]先弹出，两者在popA中的相对位置应该是push[index-1]在push[index-2]前面。

考虑几种特殊情况：

1. pushA和popA都没有元素，返回true;
2. popA[0]在pushA中找不到，此时index=-1，返回false;
3. index=0，此时应该继续找popA[1]在pushA中的index。

在第3种情况下，下面实现的代码直接返回true，这是不对的，但是通过测试了=.=
例如输入序列12345，序列14235就不可能是它的一个弹出序列。
改进此方法应该是，index=0就去找下一个pop的index然后判断那一段。（好像很麻烦啊！！！）

此方法弊端： 最坏时间复杂度O（n^2），最坏空间复杂度O（n），因为反复操作数组，要非常小心，不然会数组索引越界。

public class Solution {
    // 16ms 9380K
    public boolean IsPopOrder(int [] pushA,int [] popA) {
        if(pushA.length == 0)
            return true;
        // index 之前的弹出序列是确定的
        int index = -1;
        for(int i = 0; i < pushA.length; i++){
            if(pushA[i] == popA[0]){
                index = i;
                break;
            }
        }
        if(index > 0)
            index--;
        else if(index == 0) return true;
        else return false;
        
        int[] order = new int[index+1];
        for(int i = 0; i < order.length; i++){
            for(int j = 1; j < popA.length; j++){
                if(popA[j] == pushA[i]){
                    order[i] = j;
                }
                    
            } 
        }
        
        for(int i = 0; i < order.length - 1; i++){
            if(order[i] < order[i + 1])
                return false;
        }    
        return true;     
    }
}

法二： 借助一个辅助栈去模拟其弹出过程。

1. 将入栈序列pushA依次入栈，在这个过程中比较和popA[j]是否相等：相等则弹栈，下一次不入栈；不相等则依次入栈。当pushA索引到达尾部时，入栈完毕。
2. 依次比较栈顶元素和popA[j]是否相等，不相等则返回false；相等则弹出栈顶元素。

弊端： 第一版代码没有考虑在第一步中弹栈后不能继续将pushA入栈。后面设置一个布尔变量isBack来判断下一次是否入栈；在第二步中忘记弹栈。所以说这一版本的代码还是要考虑很多细枝末节的东西，很辛苦。

// 14ms 9372K
    public boolean IsPopOrder(int [] pushA,int [] popA) {
        if(pushA.length <= 0)
            return false;
        Stack<Integer> helpStack = new Stack<>();
        int j = 0; // 对popA进行索引
        boolean isBack = false;
        for(int i = 0; i < pushA.length;){
            if(!isBack){
                helpStack.push(pushA[i]);
                i++;
            }
                
            if(helpStack.peek() == popA[j]){
                helpStack.pop();
                j++;
                isBack = true;
            }else{
                isBack = false;
            }                 
        }
        while(!helpStack.isEmpty()){
            if(helpStack.peek() != popA[j++])
                return false;
            helpStack.pop();
                
        }
        return true;  
    }

法二的改进版本：第一版本需要使用isBack，很容易忽略以致出错，可以在相等时用while循环，依次弹出。

// 23ms 9092K
    public boolean IsPopOrder(int [] pushA,int [] popA) {
        if(pushA.length <= 0)
            return false;
        Stack<Integer> helpStack = new Stack<>();
        int j = 0; // 对popA进行索引
        for(int i = 0; i < pushA.length;i++){
            
            helpStack.push(pushA[i]);
            
            while(!helpStack.isEmpty() && helpStack.peek() == popA[j]){
                helpStack.pop();
                j++;
            }               
        }  
        return j == popA.length;  
    }