【题目描述】

【解题思路】

首先当我看到题目的时候感觉任务很复杂，有大小写字母、有数字、有括号，还得按照字母的顺序输出，一想到还有括号自己就完全没有思路不知道该怎么办？但是这道题目的限制条件是逐渐增加难度，如果大家的逻辑能力不强建议，大家不要上来就全面的考虑问题，这样只会让菜狗的我越想越混乱。根据自己仅有的做题经验，我告诉自己先让代码能满足简单的示例，比如实例中没有括号的情况，然后在这个代码的基础上怎么处理括号问题。

然后简单列举一下我的一些解题办法：
1. 既然有原子的定义，如何找到原子是要解决的问题
2. 每个原子都有对应的数量，如何确定原子对应的数量也是要解决的问题
3. 看到输出的格式是按照的原子的字典序输出，可以很容易想到用Java中的TreeMap保存原子和原子对应的数量
4. 一看到俄罗斯套娃式的括号我的第一反应是用递归的方法
5. 先处理没有括号的情况，在此基础上加入递归的代码

【没有括号的简单情况】

老实说，我感觉这道题如果不让处理括号的话感觉还是挺简单的，就是找到原子，然后找到原子对应的数量，将这样的一个原子数量对<String, Integer>保存在TreeMap中最后统一输出。
这里根据我处理字符串带括号问题的一个习惯，我先做了一个预处理，就是将String类型的输入保存在Deque<Character>类型的双向队列当中进行后续的操作。

先写出代码的大框架

class Solution {
    public String countOfAtoms(String formula) {
        // String ======> Duque
        Deque<Character> formulaDeque = new LinkedList<>();
        for(int i = 0; i < formula.length(); ++i) {
            formulaDeque.offer(formula.charAt(i));
        }
        // 解题主要函数， 保存每个原子和其对应的数量
        TreeMap<String, Integer> treeMap = countAtoms(formulaDeque);
        // 按照要求进行输出
        String res = "";
        for(String key : treeMap.keySet()) {
            if(treeMap.get(key) > 1) {
                res += key + treeMap.get(key);
            } else {
                res += key;
            }
        }
        return res;
    }

    public TreeMap<String, Integer> countAtoms(Deque<Character> formulaDeque) {
        // coding ....
    }
}

编写求原子和对应数量的函数countAtoms(Deque formulaDeque)，不考虑括号情况

下面我们将经历放在求解这样的一个函数上。我们可以遍历当前字符串的每一个字符，根据不同的字符类型处理不同情况。例如对于H2O2He3Mg4OT而言：
我们将每次找到的原子和数量保存在String atom = “” 和String digit = “”中。
1. 遇到大写字母
    - 可能是原子的第一个大写字母，此时应改追加原子字符
    - 也可能是下一个原子的第一个字符，这是就要根据已经找到的atom和digit将其加入到TreeMap中，并且更新atom和digit为找下一个原子数量对做准备。
2. 遇到小写字母
    - 追加原子字符
3. 遇到数字
    - 追加数字字符

下面贴上代码（注意遍历完好药处理一次atom和digit）

public TreeMap<String, Integer> countAtoms(Deque<Character> formulaDeque) {
        TreeMap<String, Integer> treeMap = new TreeMap<>();
        String atom = "";
        String digit = "";
        while(!formulaDeque.isEmpty()) {
            char cur = formulaDeque.poll();
            if(Character.isUpperCase(cur)) {
                if(atom.equals("")) { // 开始，遇到第一个大写字母，原子以大写字母开始，添加原子
                    atom += cur;
                } else { // 结束，遇到下一个大写字母，记录原子和数量
                    if(digit.equals("")) {  // 如果digit为空应该表示为1
                        treeMap.put(atom, treeMap.getOrDefault(atom, 0) + 1);
                    } else {
                        treeMap.put(atom, treeMap.getOrDefault(atom, 0) + Integer.parseInt(digit));
                    }
                    // 更新
                    atom = "" + cur;
                    digit = "";
                }
            }
            if(Character.isLowerCase(cur)) {
                atom += cur;
            }
            if(Character.isDigit(cur)) {
                digit += cur;
            }
        }
        // 处理最后一次
        if(!atom.equals("")) {
            if(digit.equals("")) {
                treeMap.put(atom, treeMap.getOrDefault(atom, 0) + 1);
            } else {
                treeMap.put(atom, treeMap.getOrDefault(atom, 0) + Integer.parseInt(digit));
            }
        }
        return treeMap;
    }

【处理括号的情况】

一般 “(”, “)” 需要用到递归的思路，大致的思想是

• 遇到“（” 开始递归
• 遇到“）” 结束递归
  在开始递归处的代码，我们需要将递归的结果追加到TreeMap中
  在结束递归处的代码，因为遇到“）”也可能是一个原子数量对寻找的结束标志，结束递归前要先将此时的atom和digit加入到TreeMap中，除此之外“）”后面可能会跟数字，还要根据会面的数字对此时TreeMap的数据进行翻倍，下面是代码。

public TreeMap<String, Integer> countAtoms(Deque<Character> formulaDeque) {
        TreeMap<String, Integer> treeMap = new TreeMap<>();
        String atom = "";
        String digit = "";
        while(!formulaDeque.isEmpty()) {
            char cur = formulaDeque.poll();
            if(cur == '(') { // 开始递归操作
                // 将递归的结果追加到TreeMap
                TreeMap<String, Integer> nextTreeMap = countAtoms(formulaDeque);
                for(String key : nextTreeMap.keySet()) {
                    treeMap.put(key, treeMap.getOrDefault(key, 0) + nextTreeMap.get(key));
                }
            }
            if(Character.isUpperCase(cur)) {
                if(atom.equals("")) { // 开始，遇到第一个大写字母，原子以大写字母开始，添加原子
                    atom += cur;
                } else { // 结束，遇到下一个大写字母，记录原子和数量
                    if(digit.equals("")) {
                        treeMap.put(atom, treeMap.getOrDefault(atom, 0) + 1);
                    } else {
                        treeMap.put(atom, treeMap.getOrDefault(atom, 0) + Integer.parseInt(digit));
                    }
                    // 更新
                    atom = "" + cur;
                    digit = "";
                }
            }
            if(Character.isLowerCase(cur)) {
                atom += cur;
            }
            if(Character.isDigit(cur)) {
                digit += cur;
            }
            if(cur == ')') { // 结束递归
                // 如果此时atom非空，“）”在成了一次寻找atom和digit对结束，应该返回结果前加入TreeMap
                if(!atom.equals("")) {
                    if(digit.equals("")) {
                        treeMap.put(atom, treeMap.getOrDefault(atom, 0) + 1);
                    } else {
                        treeMap.put(atom, treeMap.getOrDefault(atom, 0) + Integer.parseInt(digit));
                    }
                }
                // 如果“）”后还有数字，要根据数字值对TreeMap里面的数据进行翻倍操作
                String nextDigit = "";
                while(!formulaDeque.isEmpty() && Character.isDigit(formulaDeque.peekFirst())) {
                    nextDigit += formulaDeque.poll();
                }
                if(!nextDigit.equals("")) {
                    for(String key : treeMap.keySet()) {
                        treeMap.put(key, treeMap.get(key) * Integer.parseInt(nextDigit));
                    }
                }
                // 返回递归结果
                return treeMap;
            }
        }
        if(!atom.equals("")) {
            if(digit.equals("")) {
                treeMap.put(atom, treeMap.getOrDefault(atom, 0) + 1);
            } else {
                treeMap.put(atom, treeMap.getOrDefault(atom, 0) + Integer.parseInt(digit));
            }
        }
        return treeMap;
    }

【最后完整代码】（Java）

class Solution {
    public String countOfAtoms(String formula) {
        Deque<Character> formulaDeque = new LinkedList<>();
        for(int i = 0; i < formula.length(); ++i) {
            formulaDeque.offer(formula.charAt(i));
        }
        TreeMap<String, Integer> treeMap = countAtoms(formulaDeque);
        String res = "";
        for(String key : treeMap.keySet()) {
            if(treeMap.get(key) > 1) {
                res += key + treeMap.get(key);
            } else {
                res += key;
            }
        }
        return res;
    }

    public TreeMap<String, Integer> countAtoms(Deque<Character> formulaDeque) {
        TreeMap<String, Integer> treeMap = new TreeMap<>();
        String atom = "";
        String digit = "";
        while(!formulaDeque.isEmpty()) {
            char cur = formulaDeque.poll();
            if(cur == '(') {
                TreeMap<String, Integer> nextTreeMap = countAtoms(formulaDeque);
                for(String key : nextTreeMap.keySet()) {
                    treeMap.put(key, treeMap.getOrDefault(key, 0) + nextTreeMap.get(key));
                }
            }
            if(Character.isUpperCase(cur)) {
                if(atom.equals("")) { // 开始，遇到第一个大写字母，原子以大写字母开始，添加原子
                    atom += cur;
                } else { // 结束，遇到下一个大写字母，记录原子和数量
                    if(digit.equals("")) {
                        treeMap.put(atom, treeMap.getOrDefault(atom, 0) + 1);
                    } else {
                        treeMap.put(atom, treeMap.getOrDefault(atom, 0) + Integer.parseInt(digit));
                    }
                    // 更新
                    atom = "" + cur;
                    digit = "";
                }
            }
            if(Character.isLowerCase(cur)) {
                atom += cur;
            }
            if(Character.isDigit(cur)) {
                digit += cur;
            }
            if(cur == ')') {
                if(!atom.equals("")) {
                    if(digit.equals("")) {
                        treeMap.put(atom, treeMap.getOrDefault(atom, 0) + 1);
                    } else {
                        treeMap.put(atom, treeMap.getOrDefault(atom, 0) + Integer.parseInt(digit));
                    }
                }
                String nextDigit = "";
                while(!formulaDeque.isEmpty() && Character.isDigit(formulaDeque.peekFirst())) {
                    nextDigit += formulaDeque.poll();
                }
                if(!nextDigit.equals("")) {
                    for(String key : treeMap.keySet()) {
                        treeMap.put(key, treeMap.get(key) * Integer.parseInt(nextDigit));
                    }
                }
                return treeMap;
            }
        }
        if(!atom.equals("")) {
            if(digit.equals("")) {
                treeMap.put(atom, treeMap.getOrDefault(atom, 0) + 1);
            } else {
                treeMap.put(atom, treeMap.getOrDefault(atom, 0) + Integer.parseInt(digit));
            }
        }
        return treeMap;
    }
}

虽然代码效率不高，但是这种化繁为简，由简入深的解题思路还是很值得记录一下的，希望能帮助到大家。

出处：https://www.cnblogs.com/blogs-jch/p/14979657.html