算法打卡第十一天 栈与队列2 力扣20，32,1047，150

20. 有效的括号 （简单难度）

/**
 * @param {string} s
 * @return {boolean}
 */
var isValid = function (s) {
    let obj = {
        '(': ')',
        '{': '}',
        '[': ']'
    };
    let startKeys = ['(', '{', "["]
    let endKeys = [')', '}', ']']
    let index = -1;
    let stack = [];
    while (++index < s.length) {
        // 如果遇到左括号，就将其推入栈中
        if (startKeys.includes(s[index])) {
            stack.push(s[index]);
        } else if (endKeys.includes(s[index])) {
            // 遇到右括号出栈匹配
            if (obj[stack.pop()] !== s[index]) {
                return false;
            }
        }
    }
    // 如果栈中还有剩余元素，说明不是有效括号
    if (stack.length > 0) {
        return false;
    } else {
        return true;
    }


};

32. 最长有效括号（困难难度）

相对于20的有效括号，这题多了一个滑动窗口最大值的筛选

/**
 * @param {string} s
 * @return {number}
 */
var longestValidParentheses = function (s) {
    let index = - 1;
    let stack = [-1];
    let sum = 0;
    while (++index < s.length) {
        // 如果遇到左边箭头，将其推入栈内
        if (s[index] === '(') {
            stack.push(index)
        } else {
            // 如果不是则出栈
            stack.pop();
            if (stack.length > 0) {
                console.log(index, stack[stack.length - 1])
                sum = Math.max(index - stack[stack.length - 1], sum);
            } else {
                // 如果栈中没元素说明存在不符合的括号
                // 栈更新最后一个元素的值
                stack.push(index);
            }
        }
    }
    return sum;
};

1047. 删除字符串中的所有相邻重复项（简单难度）

/**
 * @param {string} s
 * @return {string}
 */
var removeDuplicates = function(s) {
  s = s.split('');
  for (let i = 1; i < s.length; i++) {
      if (s[i] === s[i - 1]) {
          s.splice(i-1,2);
          i-= 2;
      }
  }
  return s.join("");
};

150. 逆波兰表达式求值 (中等难度)

/**
 * @param {string[]} tokens
 * @return {number}
 */
var evalRPN = function (tokens) {
    let stack = [];
    for (let token of tokens) {
        if (isNaN(Number(token))) {
            let n1 = stack.pop();
            let n2 = stack.pop();
            switch (token) {
                case "+":
                    stack.push(n2 + n1);
                    break;
                case '-':
                    stack.push(n2 - n1);
                    break;
                case '*':

                    stack.push(n2 * n1)
                    break;
                case '/':

                    stack.push(n2 / n1 | 0);
                    break;
            }
        // 数字推入栈中
        } else {
            stack.push(Number(token));
        }
    }
    return stack[0];
};