【剑指offer】33.栈的压入、弹出序列

总目录：

算法之旅导航目录

 

1.问题描述

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

1. 0<=pushV.length == popV.length <=1000

2. -1000<=pushV[i]<=1000

3. pushV 的所有数字均不相同

 

2.问题分析

 1压栈弹栈，检查不合理之处：当前弹出元素的下一个元素，如果既不是当前的栈顶(可弹出元素)，也不是待压入元素，则错误

2压栈改良版，主要是浓缩压栈逻辑，要么压栈到和当前弹出的元素匹配，要么就压完为止

3原地栈，直接用数组索引来判断,暂时未看懂

3.代码实例

压栈弹栈

class Solution {
  public:
    stack<int> st;
    int getItemIndex(vector<int>& vec, int val) {
        int itemLength = vec.size();
        for (int i = 0; i < itemLength; i++) {
            if (vec[i] == val) {
                return i;
            }
        }

        //不存在的元素
        return -1;
    }

    bool IsPopOrder(vector<int> pushV, vector<int> popV) {
        //二者长度是否一致
        if (pushV.size() != popV.size()) {
            return false;
        }

        int itemNum = pushV.size();
        int curPushIndex = -1;
        int curItemRawIndex = 0;

        //逐元素检查弹出数据是否合理
        for (int i = 0; i < itemNum; i++) {
            //获取当前弹出元素在原集合中的索引
            curItemRawIndex = getItemIndex(pushV, popV[i]);
            if (curItemRawIndex < 0) {
                return false;
            }

            //如果已经检查至最后一个，则不必继续进行
            if ((i + 1) >= itemNum) {
                return true;
            }

            //将尚未压入内容全部压栈
            if (curItemRawIndex > curPushIndex) {
                for (int j = curPushIndex + 1; j <= curItemRawIndex; j++) {
                    st.push(pushV[j]);
                }

                //更新当前压入索引
                curPushIndex = curItemRawIndex;
            }

            //因为当前元素已经进入了弹出队列
            st.pop();

            //检查下一个弹出元素是否合理
            //不合理情况：既不等于下一个可弹出元素，也不等于尚未压入元素
            int nextItemRawIndex = getItemIndex(pushV, popV[i + 1]);
            if (popV[i + 1] != st.top() &&
                    nextItemRawIndex <= curPushIndex) {
                return false;
            }
        }

        return true;
    }
};

压栈改良版

class Solution {
public:
    bool IsPopOrder(vector<int> pushV,vector<int> popV) {
        int n = pushV.size();
        //辅助栈
        stack<int> s;
        //遍历入栈的下标
        int j = 0;
        //遍历出栈的数组
        for(int i = 0; i < n; i++){
            //入栈：栈为空或者栈顶不等于出栈数组
            while(j < n && (s.empty() || s.top() != popV[i])){
                s.push(pushV[j]);
                j++;
            }
            //栈顶等于出栈数组
            if(s.top() == popV[i])
                s.pop();
            //不匹配序列
            else
                return false;
        }
        return true;
    }
};

原地栈

class Solution {
public:
    bool IsPopOrder(vector<int> pushV,vector<int> popV) {
        //表示栈空间的大小，初始化为0
        int n = 0;
        //出栈序列的下标
        int j = 0;
        //对于每个待入栈的元素
        for(int num : pushV){
            //加入栈顶
            pushV[n] = num;
            //当栈不为空且栈顶等于当前出栈序列
            while(n >= 0 && pushV[n] == popV[j]){
                //出栈，缩小栈空间
                j++;
                n--;
            }
            n++;
        }
        //最后的栈是否为空
        return n == 0;
    }
};