LeetCodeday10

20. 有效的括号

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

示例 1：
输入：s = “()”
输出：true
示例 2：
输入：s = “()[]{}”
输出：true
示例 3：
输入：s = “(]”
输出：false

public class Leetcode20 {
    public static void main(String[] args) {
        String s = "()[]{}";
        System.out.println("isValid(s) = " + isValid(s));
    }

    public static boolean isValid(String s) {
        Stack<Character> stack = new Stack<>();
        char[] chars = s.toCharArray();
        if (chars.length % 2 != 0) {
            return false;
        }
        Map<Character, Character> map = new HashMap<>(4);
        map.put('(', ')');
        map.put('[', ']');
        map.put('{', '}');
        for (char c : chars) {
            // 遇到左括号 就放与之对应的 右括号
            if (map.containsKey(c)) {
                stack.push(map.get(c));
            }
            // 走到这说明 匹配到 右括号了
            // 栈为空 说明 右括号多了
            // 栈顶元素 不等于 c 说明 左右括号不匹配
            else if (stack.isEmpty() || stack.peek() != c) {
                return false;
            }
            // 说明匹配 消除栈顶元素
            else {
                stack.pop();
            }
        }
        // 栈不为空 说明不匹配
        return stack.isEmpty();
    }

}

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

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

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

ublic class Leetcode1047 {
    public static void main(String[] args) {
        String s = "abbaca";
        System.out.println("removeDuplicates(s) = " + removeDuplicates1(s));

    }

    public static String removeDuplicates(String s) {
        if (s.length() < 2) {
            return s;
        }
        Stack<String> stack = new Stack<>();
        for (int i = 0; i < s.length(); i++) {
            String s1 = String.valueOf(s.charAt(i));
            if (!stack.isEmpty() && stack.peek().equals(s1)) {
                stack.pop();
            } else {
                stack.push(s1);
            }

        }
        StringBuilder str = new StringBuilder();
        while (!stack.isEmpty()) {
            str.insert(0, stack.pop());
        }
        return str.toString();
    }

    /**
     * 数组模拟栈
     *
     * @param s
     * @return
     */
    public static String removeDuplicates1(String s) {
        if (s.length() < 2) {
            return s;
        }
        StringBuilder res = new StringBuilder();
        // res 中元素
        int top = -1;
        for (int i = 0; i < s.length(); i++) {
            char c = s.charAt(i);
            // 栈顶元素等于 c 就移除栈顶元素
            if (top >= 0 && res.charAt(top) == c) {
                res.deleteCharAt(top);
                top--;
            } else {
                res.append(c);
                top++;
            }
        }
        return res.toString();
    }
}

150. 逆波兰表达式求值

给你一个字符串数组 tokens ，表示一个根据 逆波兰表示法 表示的算术表达式。
请你计算该表达式。返回一个表示表达式值的整数。
注意：
有效的算符为 ‘+’、‘-’、‘*’ 和 ‘/’ 。
每个操作数（运算对象）都可以是一个整数或者另一个表达式。
两个整数之间的除法总是 向零截断 。
表达式中不含除零运算。
输入是一个根据逆波兰表示法表示的算术表达式。
答案及所有中间计算结果可以用 32 位 整数表示。

示例 1：
输入：tokens = [“2”,“1”,“+”,“3”,““]
输出：9
解释：该算式转化为常见的中缀算术表达式为：((2 + 1) 3) = 9
示例 2：
输入：tokens = [“4”,“13”,“5”,“/”,“+”]
输出：6
解释：该算式转化为常见的中缀算术表达式为：(4 + (13/ 5)) = 6
示例 3：
输入：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

public class Leetcode150 {
    public static void main(String[] args) {

        String[] tokens =  {"4","13","5","/","+"};
        System.out.println("evalRPN(tokens) = " + evalRPN(tokens));

    }

    public static int evalRPN(String[] tokens) {
        Set<String> set = new HashSet<>();
        set.add("*");
        set.add("+");
        set.add("-");
        set.add("/");
        Deque<String> deque = new ArrayDeque<>();
        for (String s : tokens) {
            boolean contains = set.contains(s);
            if(!contains){
                deque.push(s);
            }else {
                String s1 = deque.pop();
                int num2 = Integer.parseInt(s1);
                String s2 = deque.pop();
                int num1 = Integer.parseInt(s2);
                int res = res(num1, num2, s);
                deque.push(String.valueOf(res));
            }
        }
        return Integer.parseInt(deque.pop());
    }

    public static int res(int num1,int num2,String s){
        if(s.equals("+")){
            return num2+num1;
        }else if(s.equals("*")){
            return num2*num1;
        }else if(s.equals("-")){
            return num1-num2;
        }else{
            return num1/num2;
        }
    }
}