JS中的栈（含leetcode例题）＜持续更新~＞

栈(stack)

特性

先进后出

实现方式

• 基于数组实现

    // 封装栈类
    function Stack(){
      // 栈的属性
      this.items = []

      // 栈的相关操作
      // 1.push压栈
      Stack.prototype.push = function(element){
         return this.items.push(element)
      }
      // 2.pop出栈
      Stack.prototype.pop = function(){
        return this.items.pop()
      }
      // 3.peek查看栈顶
      Stack.prototype.peek = function(){
        return this.items[this.items.length - 1]
      }
      // 4.isEmpty判断栈是否为空
      Stack.prototype.isEmpty = function(){
        return this.items.length == 0
      }
      // 5.size获取个数
      Stack.prototype.size = function(){
        return this.items.length
      }
      // 6.toString转为字符串
      Stack.prototype.toString = function(){
        let res = ''
        for(let i =0;i<this.items.length;i++){
          res += this.items[i]+','
        }
        return res
      }
    }
	// 7.getMin获取最小值
	Stack.prototype.toString = function(){
    	var min = this.item[0]
    	for(var i = 1 ;i<this.item.length ; i++){
     	   if(this.item[i]<min){
     	       min = this.item[i]
     	   }
    	}
    	return min
      }

    // 栈的使用
    var s = new Stack()

• 基于链表实现

待补充

---

leetcode例题

20.字符串括号匹配

**
 * @param {string} s
 * @return {boolean}
 */
var isValid = function(s) {
    var isMatch = function(left,right){
        if(left==='(' && right===')') return true
        if(left==='[' && right===']') return true
        if(left==='{' && right==='}') return true
        return false
    }

    const stack = []
    const leftMoudle = "([{"
    const rightMoudle = "}])"
    for(let i = 0 ; i < s.length ; i++){
        if(leftMoudle.includes(s[i])){
            stack.push(s[i])
        }else if(rightMoudle.includes(s[i])){
            if(isMatch(stack[stack.length-1],s[i])){
                stack.pop()
            }else{
                return false
            }
            
        }
    }
    if(stack.length === 0){
        return true
    }else{
        return false
    }

};

155.最小栈

// 求最小值的主要思路是
// 创建另一个min_stack只用来比较当前push的最小值和min_stack的栈顶
// 谁小就把谁push进去
// 最后的最小值就是栈顶
var MinStack = function() {
    this.item = []
    this.min_stack = [Infinity]
};

/** 
 * @param {number} val
 * @return {void}
 */
MinStack.prototype.push = function(val) {
    if(val<this.min_stack[this.min_stack.length-1]){
        this.min_stack.push(val)
    }else{
        this.min_stack.push(this.min_stack[this.min_stack.length-1])
    }
    return this.item.push(val)
    
};

/**
 * @return {void}
 */
MinStack.prototype.pop = function() {
    this.min_stack.pop()
    return this.item.pop()
};

/**
 * @return {number}
 */
MinStack.prototype.top = function() {
    return this.item[this.item.length-1]
};

/**
 * @return {number}
 */
MinStack.prototype.getMin = function() {
    return this.min_stack[this.min_stack.length-1]
};

232.用两个栈实现队列

// stack1为主栈，代表队列
// stack2辅助
// push功能直接加在stack1
// pop：
// 1.先将stack1出栈，再入栈到stack2中，这样就实现了逆置，再pop掉stack2，实现删除第一个元素。
// 2.此时要注意，删除第一个元素后要再进行一遍将stack2逆置给stack1的操作，避免中间有push使得顺序错乱。
var MyQueue = function() {
    this.stack1 = []
    this.stack2 = []
};

/** 
 * @param {number} x
 * @return {void}
 */
MyQueue.prototype.push = function(x) {
    this.stack1.push(x)
};

/**
 * @return {number}
 */
MyQueue.prototype.pop = function() {
    while(this.stack1.length){
        let n = this.stack1.pop()
        this.stack2.push(n)   
    }
    const res =  this.stack2.pop()
    while(this.stack2.length){
        let n = this.stack2.pop()
        this.stack1.push(n)   
    }
    return res
};

/**
 * @return {number}
 */
MyQueue.prototype.peek = function() {
    return this.stack1[0]
};

/**
 * @return {boolean}
 */
MyQueue.prototype.empty = function() {
    if(this.stack1[0]){
        return false
    }else{
        return true
    }
};

当然，这种方式复杂度太高，需要优化

496.下一个更大元素

var nextGreaterElement = function(nums1, nums2) {
    // Map + Stack
    let map = new Map()
    let stack = []
    let res = []
    // 遍历nums2，找到每一个元素的下一个最大元素
    // 思路为：循环的元素大于栈顶元素，且栈不为空，即找到下一个最大值，将栈顶元素作为key，下一个作为value
    // 存入map，将栈顶元素pop
    nums2.forEach(item=>{
        while(stack.length && item>stack[stack.length-1]){
            map.set(stack.pop(),item)
        }
        stack.push(item)
    })
    // 剩余元素没有下一个最大值，value为-1
    stack.forEach(item=>map.set(item,-1))
    // 遍历nums1，将符合要求的push到结果中
    nums1.forEach(item=>res.push(map.get(item)))
    return res
};

之后leetcode中遇到求一个更大元素类型的题都是使用map+stack

682.棒球比赛

// 创建栈，如果默认为数字就直接push进去
// 为C则删除栈顶
// 为D则push栈顶的2倍
// 为+则计算栈顶和栈顶下一个元素之和
// 最后将栈内所有元素求和
var calPoints = function(ops) {
    let sum = 0
    const stack = []
    for(let item of ops){
       switch(item){
           case 'C':
            stack.pop()
            break
           case 'D':
            stack.push(stack[stack.length-1]*2)
            break
           case '+':
            stack.push(stack[stack.length-2]+stack[stack.length-1])
            break
           default:
            stack.push(parseInt(item))
            break
       } 
    }
    for(let i=0;i<stack.length;i++){
        sum = sum + stack[i]
    }
    return sum
};