冰寒刷题-算法相关内容 : 栈的压入,弹出序列

题目描述

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

测试案例

输入         [1,2,3,4,5],[4,5,3,2,1]

返回值        true

说明         可以通过push(1)=>push(2)=>push(3)=>push(4)=>pop()=>push(5)=>pop()=>pop()=>pop()=>pop()
              这样的顺序得到[4,5,3,2,1]这个序列，返回true   

输入          [1,2,3,4,5],[4,3,5,1,2]

返回值        false

说明          由于是[1,2,3,4,5]的压入顺序，[4,3,5,1,2]的弹出顺序，要求4，3，5必须在1，2前压入，且1，2不能弹出，
             但是这样压入的顺序，1又不能在2之前弹出，所以无法形成的，返回false    

代码实现

import java.util.*


object Solution {
    /**
     * 方法实现[辅助栈（推荐使用）]:
     * step 1：准备一个辅助栈，两个下标分别访问两个序列。
     * step 2：辅助栈为空或者栈顶不等于出栈数组当前元素，就持续将入栈数组加入栈中。
     * step 3：栈顶等于出栈数组当前元素就出栈。
     * step 4：当入栈数组访问完，出栈数组无法依次弹出，就是不匹配的，否则两个序列都访问完就是匹配的。
     *
     * 时间复杂度：O(n)，其中nnn为数组长度，最坏情况下需要遍历两个数组各一次
     * 空间复杂度：O(n)，辅助栈空间最大为一个数组的长度
     *
     * @param pushV int整型一维数组
     * @param popV int整型一维数组
     * @return bool布尔型
     */
    fun IsPopOrderI(pushV: IntArray, popV: IntArray): Boolean {
        val n: Int = pushV.size
        val s: Stack<Int> = Stack<Int>()
        var j: Int = 0
        (0 until n).forEach { i ->
            while (j < n && (s.isEmpty() || s.peek() != popV[i])) {
                s.push(pushV[j])
                j++
            }
            if (s.peek() == popV[i]) s.pop() else return false
        }
        return true
    }

    /**
     * 方法实现[辅助栈（IsPopOrderI 改进版）]:
     * step 1：用下标n表示栈空间，用j表示出栈序列的下标。
     * step 2：遍历每一个待入栈的元素，加入栈顶，即push数组中n的位置，同时增加栈空间的大小，即n的大小。
     * step 3：当栈不为空即栈顶n大于等于0，且栈顶等于当前出栈序列，就出栈，同时缩小栈的空间，即减小n。
     * step 4：最后若是栈空间大小n为0，代表全部出栈完成，否则不匹配。
     *
     * 时间复杂度：O(n)，其中nnn为数组长度，最坏还是遍历两个数组
     * 空间复杂度：O(1)，常数级变量，无额外辅助空间
     *
     * @param pushA int整型一维数组
     * @param popV int整型一维数组
     * @return bool布尔型
     */
    fun IsPopOrderII(pushA: IntArray, popV: IntArray): Boolean {
        var n: Int = 0
        var j: Int = 0
        pushA.forEach { num ->
            pushA[n] = num
            while (n >= 0 && pushA[n] == popV[j]) {
                j++
                n--
            }
            n++
        }
        return n == 0
    }
}
          n--
            }
            n++
        }
        return n == 0
    }
}