栈

stack, 又叫堆栈，一种运算受限的线性表，限定仅在表尾进行插入和删除操作的线性表。常见操作：进栈，出栈

栈与队列

队列是一种特殊的线性表，特殊之处在于它只允许在表的前端进行删除操作，而在表的后端进行插入操作，和栈一样，队列是一种操作受限制的线性表

• 队列是先进先出，栈是先进后出

leetcode 20. 有效的括号

var isValid = function(s) {
   const len = s.length
   if(len%2===1){
     return false
   }

   function isLeft(char){
      return char==='(' ||  char==='[' ||  char==='{'
   }

   const stack = [s[0]]
   for(let i=1; i<len; i++){
      let char = s[i]
      if(isLeft(char)){
         stack.push(char)
         continue
      }
      let prev = stack.pop()
      if((prev==='(' && char===')') || (prev==='[' && char===']') || (prev==='{' && char==='}')){
         continue
      }else{
         return false
      }
   }
   return stack.length ===0
};

leetcode 32. 最长有效括号

var longestValidParentheses = function(s) {
     const len = s.length
     if(len <=1){
       return 0
     }
  // s = ")()())"
    let maxlen = 0
    const stack = [-1]
    for(let i=0; i<len;i++){
      if(s[i] ==='('){
        stack.push(i)
      }else{
        stack.pop()
        const stack_len = stack.length
        if(stack_len ===0){
          stack.push(i)
        } else{
          maxlen = Math.max(maxlen, i- stack[stack_len - 1])
        }
      }
    }
    return maxlen
};

leetcode 636. 函数的独占时间

var exclusiveTime = function(n, logs) {
   const len = logs.length
   const res = new Array(n).fill(0)
   const stack = []

   let s = logs[0].split(':')
   let prev = s[0]

   let i = 1
   stack[0] = s[0]

   while(i<len){
       s = logs[i].split(':')
       if(s[1]==='start'){
           res[stack[stack.length-1]] += s[2] - prev
           stack.push(s[0])
           prev = s[2]
       } else{
           const tem = stack.pop()
           res[tem] += s[2] - prev + 1
           prev = s[2] - 0 + 1
       }
       i++
   }
   return res
}; 

剑指 Offer 09. 用两个栈实现队列