剑指OFFER第20题--表示数值的字符串

方法一：确定有限自动状态机

        该方法可以看做一种暴力枚举方法的延伸：它穷举了在任何一种情况下，对应任何输入，需要做的事情。自动机与字符串查找算法（KMP算法）有着密切联系，并且是实现正则表达式的基础。

     算法原理：开始时，自动机处于“初始状态”，随后，它顺序的读取字符串中的每一个字符，并根据当前状态和读入的字符，按照某个事先约定好的“转移规则”，从当前状态转移到下一个状态；当状态转移完成后，它就读取下一个字符。当字符串全部读取完毕后，如果自动机处于某个“接受状态”，则判定该字符串“被接受”；否则，判定该字符串“被拒绝”。需要注意的是，当没有对应的“转移规则”时，算法将提前中止，此时也可以被视作“被拒绝”。

/*
使用自动状态机
*/
class Solution {
public:
    
    enum State{
        STATE_INITIAL,
        STATE_INT_SIGN,
        STATE_INTEGER,
        STATE_POINT,
        STATE_POINT_WITHOUT_INT,
        STATE_FRACTION,
        STATE_EXP,
        STATE_EXP_SIGN,
        STATE_EXP_NUMBER,
        STATE_END,
    };
    enum CharType{
        CHAR_NUMBER,
        CHAR_EXP,
        CHAR_POINT,
        CHAR_SIGN,
        CHAR_SPACE,
        CHAR_ILLEGAL
    };
    
    CharType toCharType(char ch){
        if(ch>='0'&&ch<='9'){
            return CHAR_NUMBER;
        }else if(ch=='e'||ch=='E'){
            return CHAR_EXP;
        }else if(ch=='.'){
            return CHAR_POINT;
        }else if(ch=='+'||ch=='-'){
            return CHAR_SIGN;
        }else if(ch==' '){
            return CHAR_SPACE;
        }else{
            return CHAR_ILLEGAL;
        }
    }

    bool isNumber(string s) {
        unordered_map<State,unordered_map<CharType,State>> transfer{
            {
                STATE_INITIAL,{
                    {CHAR_SPACE,STATE_INITIAL},
                    {CHAR_NUMBER,STATE_INTEGER},
                    {CHAR_POINT,STATE_POINT_WITHOUT_INT},
                    {CHAR_SIGN,STATE_INT_SIGN}
                }
            },{
                STATE_INT_SIGN,{
                    {CHAR_NUMBER,STATE_INTEGER},
                    {CHAR_POINT,STATE_POINT_WITHOUT_INT}
                }
            },{
                STATE_INTEGER,{
                    {CHAR_NUMBER,STATE_INTEGER},
                    {CHAR_EXP,STATE_EXP},
                    {CHAR_POINT,STATE_POINT},
                    {CHAR_SPACE,STATE_END}
                }
            },{
                STATE_POINT,{
                    {CHAR_NUMBER,STATE_FRACTION},
                    {CHAR_EXP,STATE_EXP},
                    {CHAR_SPACE,STATE_END}
                }
            },{
                STATE_POINT_WITHOUT_INT,{
                    {CHAR_NUMBER,STATE_FRACTION}
                }
            },{
                STATE_FRACTION,{
                    {CHAR_NUMBER,STATE_FRACTION},
                    {CHAR_EXP,STATE_EXP},
                    {CHAR_SPACE,STATE_END}
                }
            },{
                STATE_EXP,{
                    {CHAR_NUMBER,STATE_EXP_NUMBER},
                    {CHAR_SIGN,STATE_EXP_SIGN}
                }
            },{
                STATE_EXP_SIGN,{
                    {CHAR_NUMBER,STATE_EXP_NUMBER}
                }
            },{
                STATE_EXP_NUMBER,{
                    {CHAR_NUMBER,STATE_EXP_NUMBER},
                    {CHAR_SPACE,STATE_END}
                }
            },{
                STATE_END,{
                    {CHAR_SPACE,STATE_END}
                }
            }
        };

        //遍历字符串，进行状态转移，并判定答案
        int len=s.length();
        State st=STATE_INITIAL;

        for(int i=0;i<len;i++){
            CharType typ=toCharType(s[i]);
            if(transfer[st].find(typ)==transfer[st].end()){
                return false;
            }else{
                st=transfer[st][typ];
            }
        }
        return st==STATE_INTEGER||st==STATE_POINT||st==STATE_FRACTION||st==STATE_EXP_NUMBER||st==STATE_END;
    }
};

方法二：使用暴力解法

 利用点、数字、正负号、大小写e之间的互斥关系可以将if else解法写的简单一点

class Solution {
public:
    bool isNumber(string s) {
        if(s.size() == 0) return false;

        //跳过首尾空格
        int left = 0, right = s.length() - 1;
        while(left <= right && s[left] == ' '){
            left++;
        }
        if(left > right) return false;
        while(left < right && s[right] == ' '){
            right--;
        }

        bool isNum = false;
        bool isDot = false;
        bool isEe = false;
        bool isSign = false;

        for(int i = left; i <= right; i++){
            if(s[i] >= '0' && s[i] <= '9'){
                isNum = true;
            }
            // 一个'.'；e/E后面跟一个整数（不能有'.'）
            else if(s[i] == '.' && !isDot && !isEe){
                isDot = true;
            }
            // 一个'E'或'e'；前面需要出现过数字
            else if((s[i] == 'E' || s[i] == 'e') && isNum && !isEe){
                isEe = true;
                 避免e结尾的情况 e后面得跟一个整数
                isNum = false;
            }
            // '+''-'只能出现在开头或者'E'或'e'的后一位
            else if((s[i] == '+' || s[i] == '-') && (i == left || s[i - 1] == 'E' || s[i - 1] == 'e')){
                isSign = true;
            }
            else{
                return false;
            }
        }
        // 必须以数字结尾
        return isNum;
    }
};