算法训练营day11

一、有效的括号

如果是左括号就压栈(push)，匹配到右括号时出栈

1. 若数量为奇数或数量 <= 1，匹配失败
2. 若第一个字符不是左括号，匹配失败
3. 若匹配到右括号时，栈内没有元素(没有左括号)匹配失败
4. 若元素遍历完，栈内非空则匹配失败(左右括号数量不相等)
5. 利用HashMap创建左右括号的对应关系 并且 添加 ?:? (纯技巧)巧妙解决问题

class Solution {
        //使用Map来记录左右括号对应关系
    private static final Map<Character,Character> map = new HashMap<Character,Character>(){{
        //这里的 ? ? 是为了解决边界问题，当栈为空遇到又遇到右括号时，? 对应 右括号自然返回false
        put('{','}'); put('[',']'); put('(',')'); put('?','?');
    }};
    public boolean isValid(String s) {
        //括号数量为奇数，或只有一个或零个括号，返回false
        if(s.length() % 2 != 0 || s.length() <= 1){
            return false;
        }
        //利用栈来进行计算，如果是左括号就压栈，出现有括号就弹栈，判断左右括号是否匹配
        //不匹配返回false，匹配继续遍历

        //如果第一个字符不在map的key集合中，也就不是左括号 '{', '[', '('，那么直接返回false。匹配第一个字符必须是左括号，例, }{ ，肯定匹配失败
        if(!map.containsKey(s.charAt(0))) return false;
        //添加一个 ？ 在栈中，防止空栈.removeLast()报错的情况
        LinkedList<Character> stack = new LinkedList<Character>(){{add('?');}};
        for(Character c:s.toCharArray()){
            //左括号压栈内(push)
            if(map.containsKey(c)) stack.addLast(c);
            //右括号判断出栈的左括号的value是否匹配，不匹配也返回false
            else if(map.get(stack.removeLast()) != c) return false;
        }
        //如果最后stack剩余大小为1（即add('?')），代表所有括号都匹配上了，1是true
        return stack.size() == 1;
    }
}

为什么采用HashMap的解法？

考虑到这只是三种括号的情况，如果是更多种情况匹配，代码维护非常麻烦，而这种代码在添加多种情况时只需在HashMap中添加对应key-value即可，拓展性比较强

二、删除字符串中所有相邻重复项

参考Carl哥的代码

涉及到字符串频繁变化时，要联想到 StringBuilder || StringBuffer

class Solution {
    public String removeDuplicates(String s) {
//ArrayDeque比LinkedList在除了删除元素之外会快一点
//Answer最高赞的最后一句话，The only better operation of a linked list is removing the current element during iteration.
//参考：https://stackoverflow.com/questions/6163166/why-is-LinkedList-better-than-linkedlist
        ArrayDeque<Character> deque = new ArrayDeque<>();
        char ch;
        for (int i = 0; i < s.length(); i++) {
            ch = s.charAt(i);
            //如果栈为空或者头部字符不等于当前字符，则压栈
            if (deque.isEmpty() || deque.peek() != ch) {
                deque.push(ch);
            } else {
                //否则(.peek() == ch)，则出栈
                deque.pop();
            }
        }
        StringBuilder sb = new StringBuilder();
        while (!deque.isEmpty()) {
            sb.insert(0, deque.pop());
        }
        return sb.toString();
    }
}

效率对比

1. 使用 + 号进行字符串拼接

2. 使用StringBuilder

ArrayDeque & LinkedList 的一些区别

1. ArrayDeque & LinkedList 是Deque的两个实现类
2. Another difference to bear in mind: LinkedList supports null elements, whereas ArrayDeque does not.(要记住的另一个区别是：LinkedList支持null元素，而ArrayDeque不支持。)
3. Also another small disadvantage (for real-time applications) is that on a push/add operation it takes a bit more when the internal array of the ArrayDeque is full, as it has to double its size and copy all the data.(另一个小缺点(对于实时应用程序)是，在push/add操作中，当ArrayDeque的内部数组已满时，它需要更多的时间，因为它必须将其大小加倍并复制所有数据。)
4. If your requirement is storing 100 or 200 elements, it wouldn’t make much of a difference using either of the Queues.(如果您的需求是存储100或200个元素，那么使用这两个队列中的任何一个都不会有太大区别。)
5. However, if you are developing on mobile, you may want to use an ArrayList or ArrayDeque with a good guess of maximum capacity that the list may be required to be because of strict memory constraint.(然而，如果你是在移动设备上开发，你可能想使用一个“ArrayList”或“ArrayDeque”，并猜测列表的最大容量可能是因为严格的内存约束。) 该条对应第2条 ArrayDeque在使用内存超过设定最大内存时，需要扩张至2倍(double)内存，非常消耗时间，或者因为内存无法扩张到2倍而无法运行
6. A lot of code exists, written using a LinkedList so tread carefully when deciding to use a ArrayDeque especially because it DOESN’T implement the List interface(I think that’s reason big enough). It may be that your codebase talks to the List interface extensively, most probably and you decide to jump in with an ArrayDeque. Using it for internal implementations might be a good idea… (有很多代码是用“LinkedList”编写的，所以在决定使用“ArrayDeque”时要小心，特别是因为它(ArrayDeque)没有实现“List”'接口（我认为这是足够大的原因）。您的代码库可能与List接口进行广泛的对话，最有可能的是然后你决定加入一个数组Deque。将其用于内部实现可能是一个好主意…)

三、逆波兰表达式求值

逻辑，较易

1. 遇到数字时，将数字压入栈
2. 遇到运算符时，将栈顶两个元素弹出来，第一个弹出来的在运算符右侧，第二个在左侧，计算完成后将结果压入栈

class Solution {
    public int evalRPN(String[] tokens) {
        Deque<Integer> stack = new LinkedList<Integer>();
        for (int i = 0; i < tokens.length; i++) {
            String token = tokens[i];
    //第一个点，isNumber，判断是否为数字，如果为数字则压栈，
            if (isNumber(token)) {
	// Integer.parseInt(token)，将字符串类型解析为Integer类型方便后面计算
                stack.push(Integer.parseInt(token));
            } else {
                int num2 = stack.pop();
                int num1 = stack.pop();
    //switch(var) case 可应用于对应关系比较少的情景
                switch (token) {
                    case "+":
                        stack.push(num1 + num2);
                        break;
                    case "-":
                        stack.push(num1 - num2);
                        break;
                    case "*":
                        stack.push(num1 * num2);
                        break;
                    case "/":
                        stack.push(num1 / num2);
                        break;
                    default:
                }
            }
        }
        return stack.pop();
    }

    public boolean isNumber(String token) {
        return !("+".equals(token) || "-".equals(token) || "*".equals(token) || "/".equals(token));
    }
}

因为出现了对应关系，就联想想到了HashMap，但运算符作为value，代码用map.get()放到两个计算数字中间无法编译成功，就只能存储两个数字之间计算关系，又要引入函数式编程，下面代码简单看看了解一下就行

class Solution {
    public int evalRPN(String[] tokens) {
        Map<String, BiFunction<Integer, Integer, Integer>> operators = new HashMap<>();
        //key是运算符，value是”计算关系“
        operators.put("+", (a, b) -> a + b);
        operators.put("-", (a, b) -> a - b);
        operators.put("*", (a, b) -> a * b);
        operators.put("/", (a, b) -> a / b);

        Deque<Integer> stack = new LinkedList<>();
        for (String token : tokens) {
            if (operators.containsKey(token)) {
                int num2 = stack.pop();
                int num1 = stack.pop();
//函数式编程重要接口 BiFunction，根据token获取对应的计算关系operation
                BiFunction<Integer, Integer, Integer> operation = operators.get(token);
    			//计算结果后再将结果入栈
                stack.push(operation.apply(num1, num2));
            } else {
                stack.push(Integer.parseInt(token));
            }
        }
        
        return stack.pop();
    }
}