代码随想录算法训练营第十一天 | 20. 有效的括号 1047. 删除字符串中的所有相邻重复项 150. 逆波兰表达式求值

20. 有效的括号

20. 有效的括号

给定一个只包括 '('，')'，'{'，'}'，'['，']' 的字符串 s ，判断字符串是否有效。

有效字符串需满足：

1. 左括号必须用相同类型的右括号闭合。
2. 左括号必须以正确的顺序闭合。
3. 每个右括号都有一个对应的相同类型的左括号。

 

示例 1：

输入： s = "()"
输出： true

示例 2：

输入： s = "()[]{}"
输出： true

示例 3：

输入： s = "(]"
输出： false

/**
 * @param {string} s
 * @return {boolean}
 */
var isValid = function(s) {
    if (s.length < 2) {
        return false;
    }

    const map = {
        '{': '}',
        '(': ')',
        '[': ']'
    };

    const stack = [];

    for (let i = 0; i < s.length; i++) {
        if (s[i] === '{' || s[i] === '(' || s[i] === '[') {
            stack.push(map[s[i]]);
        } else if (stack.length && stack[stack.length - 1] === s[i]) {
            stack.pop();
        } else {
            return false;
        }
    }

    return stack.length === 0;
};

1047. 删除字符串中的所有相邻重复项

给出由小写字母组成的字符串 S，重复项删除操作会选择两个相邻且相同的字母，并删除它们。

在 S 上反复执行重复项删除操作，直到无法继续删除。

在完成所有重复项删除操作后返回最终的字符串。答案保证唯一。

 

示例：

输入： "abbaca"
输出： "ca"
解释：
例如，在 "abbaca" 中，我们可以删除 "bb" 由于两字母相邻且相同，这是此时唯一可以执行删除操作的重复项。之后我们得到字符串 "aaca"，其中又只有 "aa" 可以执行重复项删除操作，所以最后的字符串为 "ca"。

 

提示：

1. 1 <= S.length <= 20000
2. S 仅由小写英文字母组成。

/**
 * @param {string} s
 * @return {string}
 */
var removeDuplicates = function(s) {
    const stack = [];

    for (let i = 0; i < s.length; i++) {
        if (stack.length && s[i] === stack[stack.length - 1]) {
            stack.pop();
        } else {
            stack.push(s[i]);
        }
    }

    return stack.join('')
};

150. 逆波兰表达式求值

/**
 * @param {string[]} tokens
 * @return {number}
 */
var evalRPN = function(tokens) {
    const stack = [];
    const validKeys = ['+', '-', '*', '/'];
    
    for (let i = 0; i < tokens.length; i++) {
        if (validKeys.indexOf(tokens[i]) !== -1) {
            let n1 = stack.pop();
            let n2 = stack.pop();

            n1 = parseInt(n1, 10);
            n2 = parseInt(n2, 10)

            let result;

            switch(tokens[i]) {
                case '+':
                    result = n2 + n1;
                    break;
                case '-':
                    result = n2 - n1;
                    break;
                case '*':
                    result = n2 * n1;
                    break;
                case '/':
                    result = n2 / n1 | 0; // 按位或，或者用Math.trunc()
                    break;
                default:
                    break;
            }

            stack.push(result);
        } else {
            stack.push(tokens[i]);
        }
    }


    return stack.pop();
};