剑指offer面试题31(java版):栈的压入,弹出序列

welcome to my blog

剑指offer面试题31(java版):栈的压入,弹出序列

题目描述

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

笔记

• 不用专门为pushA创建栈, 直接使用辅助栈即可
• 核心: 如果遍历完出栈序列popA后, 辅助栈s为空, 说明popA是A的一个出栈序列
• 对于popA[i]来说, 如果s.peek()!=popA[i],那么要继续向s中压入popA的元素(得保证popIndex没有越界), 如果popIndex越界或者s.peek() == popA[i] 则停止压栈, 判断s.peek()是否等于popA[i],是的话则弹出s的栈顶元素

思路

• 如果popA[i]等于s的栈顶数字, 那么直接弹出栈顶数字, 继续判断popA[i+1]
• 如果popA[i]不等于s的栈顶数字, 那么继续向s中压入没有入栈的数字, 直到popA[i]等于s的栈顶数字
• 如果所有数字都入栈后, popA[i]依然不等于s的栈顶数字, 那么popA不是A的一个出栈序列
• 如果遍历完popA的所有元素后, s为空, 那么说明popA是A的一个出栈序列

第三次做, 使用辅助栈进行压入和弹出; 遍历pushA; 先压入再判断(单次压入,循环判断)

import java.util.Stack;

public class Solution {
    public boolean IsPopOrder(int [] pushA,int [] popA) {
        if(popA==null)
            return true;
        if(pushA==null)
            return false;
        //here, popA!=null && pushA!=null
        Stack<Integer> s = new Stack<>();
        int popIndex=0;
        for(int i=0; i<pushA.length; i++){
            s.push(pushA[i]);
            while(!s.isEmpty()&&s.peek()==popA[popIndex]){
                s.pop();
                popIndex++;
            }
        }
        return popIndex==popA.length;
    }
}

第三次做, 使用辅助栈进行压入和弹出; 遍历popA; 先压入再判断(循环压入,单次判断)

import java.util.Stack;

public class Solution {
    public boolean IsPopOrder(int [] pushA,int [] popA) {
        if(popA==null)
            return true;
        if(pushA==null)
            return false;
        //here, popA!=null && pushA!=null
        Stack<Integer> s = new Stack<>();
        int pushIndex=0;
        for(int i=0; i<popA.length; i++){
            //先压入
            while(s.isEmpty() || (s.peek()!=popA[i]) && pushIndex < pushA.length){
                s.push(pushA[pushIndex++]);
            }
            //再判断
            if(s.peek()==popA[i])
                s.pop();
        }
        return s.isEmpty();
    }
}

第二次做，被if，else卡了一下

• 使用一个辅助栈实际模拟出入栈
• 难是不难，就是在循环中使用if else不当，导致循环结束时还少一次判断，说明这个思路不好
• 好的思路是遍历pushA或者popA

import java.util.Stack;
/*
创建一个辅助栈s，两个索引用于访问pushA,popA
如果s为空，向s中压入pushA的元素
判断s栈顶元素是否等于popA[popIndex]
    不等的话，pushIndex++， 继续将pushA[pushIndex]压入s，直到相等
    相等的话，弹出s栈顶元素，popIndex++
如果遍历完pushA，但没用遍历完popA，则说明popA不是pushA的弹出序列，返回false
如果遍历完pushA，同时也遍历完了popA，则说明popA是pushA的弹出序列，返回true
*/
public class Solution {
    public boolean IsPopOrder(int [] pushA,int [] popA) {
      //input check
        if((pushA==null&&popA!=null)||(pushA!=null&&popA==null))
            return false;
        if(pushA==null&&popA==null)
            return true;
        if(pushA.length != popA.length)
            return false;
        //
        Stack<Integer> s = new Stack<>();
        int popIndex=0;
        /*
        vital:遍历pushA，每一次都向s压入一个元素
        这样比用if(s.isEmpty()) else好， 因为能够保证每轮循环都压入一个元素
        */
        for(int i=0; i<pushA.length; i++){
            s.push(pushA[i]);
            while(!s.isEmpty() && s.peek() == popA[popIndex]){
                s.pop();
                popIndex++;
            }
        }
        return s.isEmpty();
    }
}

import java.util.Stack;
public class Solution {
    public boolean IsPopOrder(int [] pushA,int [] popA) {
        // input check
        if(pushA == null || popA == null)
        return false;
        //execute
        Stack<Integer> s = new Stack<Integer>();
        // 如果遍历完出栈序列popA后, 辅助栈s为空, 那么说明popA是A的一个出栈序列
        int pushIndex=0;
        for(int i=0; i<popA.length; i++){
            if(s.empty())
                s.push(pushA[pushIndex++]);
            while(pushIndex < pushA.length && s.peek() != popA[i]){
                s.push(pushA[pushIndex++]);
            }
            // 有两种情况会跳出while循环
            // 1.pushIndex==pushA.length 2.s.peek() == popA[i], 针对这两种情况,有两种处理方式
            // 1.
            if(s.peek() == popA[i])
                s.pop();
            else  // 2.
                return false;
        }
        return s.empty();
    }
}