05.替换空格

过于简单

  • 核心思想在于新建一个string来方便操作
  • 使用insert来插入字符串或者字符

    字符串的插入和删除

    image.png
    1. class Solution {
    2. public:
    3. string replaceSpace(string s) {
    4. string ret;
    5. for(int i = 0; i < s.size(); i++){
    6. if(s[i] == ' '){
    7. ret.insert(ret.size(), "%20");
    8. continue;
    9. }
    10. ret.insert(ret.size(), 1, s[i]);
    11. }
    12. return ret;
    13. }
    14. };

    58.-Ⅱ左旋转字符串

    这一题虽然简单但是有牛比写法

    先贴出自己的笨比写法

    1. class Solution {
    2. public:
    3. string reverseLeftWords(string s, int n) {
    4. string str = s.substr(0, n);//这里的0表示从0开始,n代表多少位
    5. s.erase(0, n);
    6. s.insert(s.size(), str);//这里的在指定位置插入字符串不包括插入前的最后一位
    7. return s;
    8. }
    9. };

    究极靓仔写法

    直接复制一段拼接在后面,然后取子串就行了 ```cpp class Solution { public: string reverseLeftWords(string s, int n) {
    1. int len = s.size();
    2. s += s;
    3. return s.substr(n,len);
    } };
<a name="qWFGV"></a>
### [剑指 Offer 20. 表示数值的字符串](https://leetcode-cn.com/problems/biao-shi-shu-zhi-de-zi-fu-chuan-lcof/)
基本就是暴力解法了
```cpp
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;
    }
};

简单一点

class Solution {
public:
    bool hasE, hasNum, isFloat; 
    bool isNumber(string& s) {
        for(int i = 0; i < s.size(); i++) {
            auto c = s[i];
            // 符号位只能在首位或E的后一位
            if((c == '-' || c == '+') && (i == 0 || s[i - 1] == 'e' || s[i - 1] == 'E')) {

            }else if((c == 'e' || c == 'E') && !hasE && hasNum) {
            //只存在一个E, 前面必须有数字, 后面也必须有数字
                hasE = true;
                hasNum = false;
            }else if(c == '.' && !isFloat && !hasE) {
            //只存在一个小数点, 不能在E的后面
                isFloat = true;
            }else if(isdigit(c)) {
                hasNum = true;
            }else {
                return false;
            }
        }
        return hasNum;
    }
};

剑指 Offer 67. 把字符串转换成整数

一般都是使用ascll码来写的

class Solution {
private:
    int to_int(string& s) {
        int num = 0;
        int len = s.length() - 1;
        bool neg = false;
        for(int i = 0; i <= len; i++) {
            if(i == 0 && s.at(i) == '-') {
                //如果有负号,标记一下
                neg = true;
                continue;
            }
            //#define INT_MAX 2147483647
            //这里小心,可能是2147483645 这样的数是不会越界所以需要特判
            if((num == INT_MAX/10 && s.at(i)>'7') || num > INT_MAX/10) {
                if(neg) return INT_MIN;
                return INT_MAX;
            }
            num = num * 10 + (s.at(i)-'0');
        }
        if(neg) num = -num;
        return num;
    }
bool is_num(char& c) {
    return c >= '0' && c <= '9';
}
public:
    int strToInt(string str) {
        string num;
        int len = str.length() - 1;
        int i = 0;

        //去除前缀' '
        while(i <= len && str.at(i) == ' ') i++;
        //空串返回0
        if(i > len) return 0;

        //获取非空首个字符
        char start = str.at(i);

        //如果只剩一个字符且不为数字,返回0
        if(!is_num(start) && i == len) return 0;
        //符合题意的情况
        //1.开头是符号且跟着数字的,2.开头就是数字的情况
        else if(is_num(str.at(i)) || (( start == '-' || start == '+' ) && i < len && is_num(str.at(++i)))  ) {
            //'+'号直接舍去
            if(start == '-') {
                num += move(start);
            }

            //num拼接后序所有数字字符
            while(i <= len && is_num(str.at(i))) {
                num += move(str.at(i));
                i++;
            }

        }
        return to_int(num);
    }
};
。

剑指 Offer II 032. 有效的变位词(数组代表字符串)

  • 用一个26位的数组来表示字符串

    class Solution {
    public:
      bool isAnagram(string s, string t) {
          if (s.length() != t.length() || s == t) {
              return false;
          }
          vector<int> table(26, 0);
          for (auto& ch: s) {
              table[ch - 'a']++;
          }
          for (auto& ch: t) {
              table[ch - 'a']--;
              if (table[ch - 'a'] < 0) {
                  return false;
              }
          }
          return true;
      }
    };
    

    剑指 Offer II 035. 最小时间差(排序)

  • 东西不多,先排序然后相邻的进行比较

  • 唯一值得在意的点就是如果输入的个数大于1440就证明一定有重复的,直接返回0即可。 ```cpp class Solution { //转换成分钟 int getMinutes(string &t) {
      return (int(t[0] - '0') * 10 + int(t[1] - '0')) * 60 + int(t[3] - '0') * 10 + int(t[4] - '0');
    
    }

public: int findMinDifference(vector &timePoints) { if(timePoints.size() > 1440) return 0; sort(timePoints.begin(), timePoints.end()); int ans = INT_MAX; int t0Minutes = getMinutes(timePoints[0]); int preMinutes = t0Minutes; for (int i = 1; i < timePoints.size(); ++i) { int minutes = getMinutes(timePoints[i]); ans = min(ans, minutes - preMinutes); // 相邻时间的时间差 preMinutes = minutes; } //这里是因为一天有1440分钟 ans = min(ans, t0Minutes + 1440 - preMinutes); // 首尾时间的时间差 return ans; } }; ```