栈的应用（有效的括号 ，删除字符串中的所有相邻重复项 ， 逆波兰表达式求值 ）

1.有效的括号
给定一个只包括 ‘(’，‘)’，‘{’，‘}’，‘[’，‘]’ 的字符串 s ，判断字符串是否有效。
有效字符串需满足：
左括号必须用相同类型的右括号闭合。
左括号必须以正确的顺序闭合。
每个右括号都有一个对应的相同类型的左括号。

不匹配的三种情况：

- 1.第一种情况，字符串中左方向的括号多余了，所以不匹配
- 2.第二种情况，字符串中括号没有多余，但是括号的类型不匹配；
- 3.第三种情况，字符串中右方向的括号多余了，所以不匹配；

三种类型的括号（），{}，[]，遍历匹配括号类型，匹配到左括号把类型一致的右括号压入栈中，匹配到右括号将栈中的右括号弹出，遍历完之后，栈中还存在元素 或者栈提前为空了，判断为无效；

/**
 * @param {string} s
 * @return {boolean}
 */
var isValid = function(s) {
    if(s.length % 2 != 0){
        return false;
    }
    let arr = [];
    for(let i = 0; i < s.length;i++){
        if(s[i] == "("){
            arr.push(")");
        }else if(s[i] == "{"){
            arr.push("}");
        }else if(s[i] == "["){
            arr.push("]");
        }else if(arr.length == 0 || arr.pop() != s[i]){
            return false;
        }
    }
    if(arr.length == 0){
        return true
    }
    return false;
};

2.删除字符串中的所有相邻重复项
力扣链接
给出由小写字母组成的字符串 S，重复项删除操作会选择两个相邻且相同的字母，并删除它们。
在 S 上反复执行重复项删除操作，直到无法继续删除。
在完成所有重复项删除操作后返回最终的字符串。答案保证唯一

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

定义一个空栈，遍历字符串数组，判断栈中栈顶元素是否与当前比遍历的值是否相等，相等栈顶元素出栈，不相等将当前遍历的值压入栈中；思路与有效的括号基本一致。

/**
 * @param {string} s
 * @return {string}
 */
var removeDuplicates = function(s) {
    let arr = s.split('');
    let result = [];
    console.log(arr)
    for(let i = 0;i<arr.length;i++){
        if(result.length == 0 || result[result.length-1] != arr[i]){
            result.push(arr[i]);
        }else{
            result.pop();
        }
    }
    return result.join('');
};

3.逆波兰表达式求值
力扣链接
给你一个字符串数组 tokens ，表示一个根据 逆波兰表示法 表示的算术表达式。

请你计算该表达式。返回一个表示表达式值的整数。

输入：tokens = [“2”,“1”,“+”,“3”,“*”]
输出：9
解释：该算式转化为常见的中缀算术表达式为：((2 + 1) * 3) = 9

输入：tokens = [“10”,“6”,“9”,“3”,“+”,“-11”,““,”/“,””,“17”,“+”,“5”,“+”]
输出：22
解释：该算式转化为常见的中缀算术表达式为：
((10 * (6 / ((9 + 3) * -11))) + 17) + 5
= ((10 * (6 / (12 * -11))) + 17) + 5
= ((10 * (6 / -132)) + 17) + 5
= ((10 * 0) + 17) + 5
= (0 + 17) + 5
= 17 + 5
= 22

遇到整数压入栈中，遇到运算符，pop出栈的两个整数，根据有效运算符 ，计算这两个数的运算之后的值，压入栈中，直到遍历完整个字符串数组；

/**
 * @param {string[]} tokens
 * @return {number}
 */
var evalRPN = function(tokens) {
    let arr = [];
    for(let i = 0;i<tokens.length;i++){
        if(tokens[i] == "+" || tokens[i] == "-" || tokens[i] == "*" || tokens[i] == "/"){
            // console.log(arr);
            let num1 = parseInt(arr.pop());
            let num2 = parseInt(arr.pop());
            console.log(num2,num1)
            if(tokens[i] == "+"){
                let num3 = num2 + num1;
                //   console.log(num1,num2,num3)
                arr.push(num3);
            }else if(tokens[i] == "-"){
                arr.push((num2 - num1));
            }else if(tokens[i] == "*"){
                arr.push((num2 * num1))
            }else{
                 let num4 =  num2 / num1 >0? Math.floor(num2 / num1):Math.ceil(num2/num1);
                 console.log(num4);
                arr.push(num4);
            }
        }else{
            arr.push(tokens[i]);
        }
    }
    return arr[0];
};