字符串操作类的模板（字符串篇&&刷题笔记）

力扣上关于字符串的题目中有一类很特殊，就是给一个字符串组成的句子(带空格或标点)，然后对句中单个字符串进行一系列处理的题目。在做完所有这类题目后我总结出了一个模板，套用模板可以直接秒杀所有这类题目。
注意：这类题目c++代码较少，本模板只针对c++处理字符串的方法，其他语言的学一下思路即可

思路分析
这类题目我的惯常做法，也是核心思想，就是先把句子中所有字符串取出放入字符串数组，再对数组中的字符串进行操作后重新连接即可，具体问题具体细节还需要按题目要求分析
而遍历句子取字符串的思路，就是遇到字符把它放入临时字符串，遇到空格或者标点(如果有标点)，就把临时字符串输出，并且清空
需要注意的是

模板代码
这类题目可以分为两类，一类是有前置或者后置空格的，另一类是没有前置和后置空格的。
1、如果有前后置空格，那么必须判断临时字符串非空才能输出，否则会输出空串
模板如下：

 s += " "; //这里在最后一个字符位置加上空格，这样最后一个字符串就不会遗漏
    string temp = "";  //临时字符串
    vector<string> res; //存放字符串的数组
    for (char ch : s)  //遍历字符句子
    {
        if (ch == ' ') //遇到空格
        {
            if (!temp.empty()) //临时字符串非空
            {
                res.push_back(temp);
                temp.clear();  //清空临时字符串
            }
        }
        else
            temp += ch; 
    }

2、没有前后置的空格不需要判断空串

s += " ";
    string temp = "";
    vector<string> res;
    for (char ch : s)
    {
        if (ch == ' ')
        {
            res.push_back(temp);
            temp.clear();
        }
        else
            temp += ch;
    }

模板就是这么清晰简单！下面来看具体题目分析

58. 最后一个单词的长度
    直接套用模板1，返回数组尾元素长度(数组为空返回0)

int lengthOfLastWord(string s)
{
    if (s.empty()) 
        return 0;
    s += " ";
    string temp = "";
    vector<string> res;
    for (char ch : s)
    {
        if (ch == ' ')
        {
            if (!temp.empty()) //要不要判断非空取决于给定的字符串有没有前置或者后置的空格
            {
                res.push_back(temp);
                temp.clear();
            }
        }
        else
            temp += ch;
    }
    if (res.empty())
        return 0;
    return res.back().size();
}

557. 反转字符串中的单词 III
     套用模板2+反转字符串数组每个单词+重新连接

string reverseWords(string s)
{
    if (s.empty())
        return 0;
    s += " ";
    string temp = "";
    vector<string> res;
    for (char ch : s)
    {
        if (ch == ' ')
        {
            res.push_back(temp);
            temp.clear();
        }
        else
            temp += ch;
    }
    s.clear();
    for (string &str : res)
    {
        reverse(str.begin(), str.end());
        s += str + ' ';
    }
    s.pop_back(); //注意最后多加了一个空格要去掉
    return s;
}

剑指 Offer 58 - I. 翻转单词顺序
给定一个有前置和后置空格的句子，翻转整体的字符串顺序，并把前置后置空格去掉
模板1+反转整个字符数组+重新连接

string reverseWords(string s)
{
    if (s.empty())
        return "";
    s += " ";
    string temp = "";
    vector<string> res;
    for (char ch : s)
    {
        if (ch == ' ')
        {
            if (!temp.empty())
            {
                res.push_back(temp);
                temp.clear();
            }
        }
        else
            temp += ch;
    }
    s.clear();
    reverse(res.begin(), res.end());
    for (string &str : res)
        s += str + ' ';
    s.pop_back();
    return s;
}

1816. 截断句子
      把一个句子截断为只有前k个单词
      模板2+连接字符数组前k个字符串

string truncateSentence(string s, int k)
{
    s += " ";  //在句子末尾加一个空格，这样最后一个单词就不会因为没有后面的空格而被遗漏
    string temp = "";
    vector<string> res;
    for (char ch : s)
    {
        if (ch == ' ') //如果遇到空格就输出前面的字符串
        {
            res.push_back(temp);
            temp.clear();
        }
        else
            temp += ch;
    }
    for (int i = 0; i < k; i++)
        temp += res[i] + ' ';
    temp.pop_back();
    return temp;
}

1805. 字符串中不同整数的数目
      给定一个由字母和数字组成的字符串，求所有被字母分隔的不重复的整数的个数(注意有前导0的不算)
      这道题很考验细节，基本思路：模板1，把所有字符串放到集合中去重

int numDifferentIntegers(string word)
{
    set<string> s;
    string temp = "";
    word += 'a';  //在字符串的末尾加上一个字母，这样遍历到最后的时候如果有整数就不会被遗漏
    for (char ch : word)
    {
        if (isalpha(ch)) 
        {
            if (!temp.empty()) //如果遇到字母且临时字符串非空，就把它加入集合并重置临时字符串
            {
                s.insert(temp);
                temp.clear(); 
            }
        }
        else  //如果遇到数字
        {
            if (temp == "0")  //如果之前有过前导0(注意这里不是temp.back()=='0',因为前导0的前面肯定是字母,如果不是字母就不是前导0)
                temp.clear(); //清空前导0
            temp += ch;
        }
    }
    return s.size(); //集合大小就是不同整数数量
}

819. 最常见的单词
     给定一个段落 (paragraph) 和一个禁用单词列表 (banned)。返回出现次数最多，同时不在禁用列表中的单词。
     哈希表+模板1+自定义排序

string mostCommonWord(string paragraph, vector<string> &banned)
{
    paragraph += ' ';
    string temp = "";
    map<string, int> m;   //哈希表记录单词出现频次
    set<string> ban(banned.begin(), banned.end()); //把禁用列表放到集合中方便查找
    for (char ch : paragraph) 
    {
        if (!isalpha(ch)) 
        {
            if (!temp.empty())
            {
                m[temp]++;
                temp.clear();
            }
        }
        else
            temp += tolower(ch);  //注意返回的是小写字母
    }
    vector<string> words;
    for (auto p : m)
        words.push_back(p.first);
    sort(words.begin(), words.end(), [&](string &s, string &p) { return m[s] > m[p]; }); //按照频次降序
    if (banned.empty()) //如果没有禁用单词，直接返回排序后列表首元素
        return words[0];
    for (auto w : words) //否则在禁用列表中查找，第一个没有的单词就返回
        if (ban.find(w) == ban.end())
            return w;
    return "";
}

824. 山羊拉丁文
     模板2+分类重新连接

string toGoatLatin(string s)
{
    s += " ";
    string temp = "";
    string vowels = "aeiouAEIOU";
    vector<string> res;
    for (char ch : s)
    {
        if (ch == ' ')
        {
            res.push_back(temp);
            temp.clear();
        }
        else
            temp += ch;
    }
    s.clear();
    for (int i = 0; i < res.size(); i++)
    {
        if (vowels.find(res[i][0]) != -1)
            s += res[i];
        else
        {
            string t = res[i] + res[i][0];
            t.erase(t.begin());
            s += t;
        }
        s += "ma";
        s.insert(s.size(), i + 1, 'a');
        s += ' ';
    }
    s.pop_back();
    return s;
}

1455. 检查单词是否为句中其他单词的前缀
      给定句子和一个单词，在句子中的所有单词中查找其是否为某个单词前缀，返回该单词索引(从1开始)
      模板2+查找

i

nt isPrefixOfWord(string s, string searchWord)
{
    s += " ";
    string temp = "";
    vector<string> res;
    for (char ch : s)
    {
        if (ch == ' ')
        {
            res.push_back(temp);
            temp.clear();
        }
        else
            temp += ch;
    }
    for (int i = 0; i < res.size(); i++)
        if (res[i].find(searchWord) == 0)
            return i + 1;
    return -1;
}

1592. 重新排列单词间的空格
      模板1，这道题很考验细节，具体见注释

string reorderSpaces(string s)
{
    s += " ";
    string temp = "";
    vector<string> res;
    int cnt = -1;
    for (char ch : s)
    {
        if (ch == ' ')
        {
            cnt++;
            if (!temp.empty())
            {
                res.push_back(temp);
                temp.clear();
            }
        }
        else
            temp += ch;
    }
    int n = res.size();
    s.clear();
    if (n == 1)  //注意一个单词要单独考虑，直接把所有空格放到单词后面
    {
        s += res[0];
        s.insert(s.size(), cnt, ' ');
        return s;
    }
    //前面不考虑一个单词的话，这里分母上就会出现0，blank为平均分配的空格个数，remain为剩下空格个数
    int blank = cnt / (n - 1), remain = cnt - blank * (n - 1);
    for (int i = 0; i < res.size() - 1; i++) //重新连接字符串并加上空格
    {
        s += res[i];
        s.insert(s.size(), blank, ' ');
    }
    s += res.back();  //连接最后一个字符串
    if (remain > 0)  //如果有剩余的空格就全放到字符串末尾
        s.insert(s.size(), remain, ' ');
    return s;
}

1859. 将句子排序
      句子中的每个单词最后都有一个数字，按照数字给单词排序
      模板2+自定义排序+重新连接

string sortSentence(string s)
{
    s += " ";
    string temp = "";
    vector<string> res;
    for (char ch : s)
    {
        if (ch == ' ')
        {
            res.push_back(temp);
            temp.clear();
        }
        else
            temp += ch;
    }
    s.clear();
    sort(res.begin(), res.end(), [&](string &a, string &b) { return a.back() < b.back(); });
    for (auto &str : res)
    {
        str.pop_back();
        s += str + ' ';
    }
    s.pop_back();
    return s;
}