C++刷题 -- 字符串

C++刷题 – 字符串

---

1.重复的子字符串

https://leetcode.cn/problems/repeated-substring-pattern/submissions/490209402/
暴力解法
第一个for循环用来标定子串的末尾，根据末尾取出子串
第二个while循环用来检查原字符串是否由子串构成

class Solution {
public:
    bool repeatedSubstringPattern(string s) {
        for(int i = 0; i < s.size(); i++)
        {
            if(s.size() % (i + 1) != 0)
            {
                continue;
            }
            if(i >= s.size() / 2)
            {
                break;
            }
            string subStr = s.substr(0, i + 1);
            int length = i + 1;
            int pos = 0;
            while(pos < s.size())
            {
                if(subStr == s.substr(pos, length))
                {
                    pos += length;
                }
                else
                {
                    break;
                }
                if(pos == s.size())
                {
                    return true;
                }
            }
        }
        return false;
    }
};

• 时间复杂度: O(n^2)
• 空间复杂度: O(1)

移动匹配
当一个字符串s：abcabc，内部由重复的子串组成，那么这个字符串的结构一定是这样的：

也就是由前后相同的子串组成。

那么既然前面有相同的子串，后面有相同的子串，用 s + s，这样组成的字符串中，后面的子串做前串，前面的子串做后串，就一定还能组成一个s，如图：

所以判断字符串s是否由重复子串组成，只要两个s拼接在一起，里面还出现一个s的话，就说明是由重复子串组成。

当然，我们在判断 s + s 拼接的字符串里是否出现一个s的的时候，要刨除 s + s 的首字符和尾字符，这样避免在s+s中搜索出原来的s，我们要搜索的是中间拼接出来的s。

class Solution {
public:
    bool repeatedSubstringPattern(string s) {
        string t = s + s;
        t.erase(t.begin()); t.erase(t.end() - 1); // 掐头去尾
        if (t.find(s) != std::string::npos) return true; // r
        return false;
    }
};

• 时间复杂度: O(n)
• 空间复杂度: O(1)

不过这种算法最终还是要判断一个字符串中是由存在一个子串，该类库函数的实现可以使用KMP算法。

2.替换数字

https://kamacoder.com/problempage.php?pid=1064
https://programmercarl.com/kama54.%E6%9B%BF%E6%8D%A2%E6%95%B0%E5%AD%97.html#%E6%80%9D%E8%B7%AF

• 如果想把这道题目做到极致，就不要只用额外的辅助空间了！ （不过使用Java刷题的录友，一定要使用辅助空间，因为Java里的string不能修改）

首先扩充数组到每个数字字符替换成 “number” 之后的大小。

例如 字符串 “a5b” 的长度为3，那么 将 数字字符变成字符串 “number” 之后的字符串为 “anumberb” 长度为 8。

• 然后从后向前替换数字字符，也就是双指针法，过程如下：i指向新长度的末尾，j指向旧长度的末尾。
  
• 这么做有两个好处：
  不用申请新数组。
  从后向前填充元素，避免了从前向后填充元素时，每次添加元素都要将添加元素之后的所有元素向后移动的问题。

#include<iostream>
using namespace std;
int main() {
    string s;
    while (cin >> s) {
        int count = 0; // 统计数字的个数
        int sOldSize = s.size();
        for (int i = 0; i < s.size(); i++) {
            if (s[i] >= '0' && s[i] <= '9') {
                count++;
            }
        }
        // 扩充字符串s的大小，也就是每个空格替换成"number"之后的大小
        s.resize(s.size() + count * 5);
        int sNewSize = s.size();
        // 从后先前将空格替换为"number"
        for (int i = sNewSize - 1, j = sOldSize - 1; j < i; i--, j--) {
            if (s[j] > '9' || s[j] < '0') {
                s[i] = s[j];
            } else {
                s[i] = 'r';
                s[i - 1] = 'e';
                s[i - 2] = 'b';
                s[i - 3] = 'm';
                s[i - 4] = 'u';
                s[i - 5] = 'n';
                i -= 5;
            }
        }
        cout << s << endl;
    }
}

3.反转字符串

https://leetcode.cn/problems/reverse-string/description/
双指针分别指向头尾，交换两指针的元素，然后同时向内收缩

class Solution {
public:
    void reverseString(vector<char>& s) {
        size_t begin = 0, end = s.size() - 1;
        while(begin < end)
        {
            swap(s[begin], s[end]);
            begin++;
            end--;
        }
    }
};

4.翻转字符串里的单词

https://leetcode.cn/problems/reverse-words-in-a-string/description/
如果不使用库函数且空间复杂度为O(1)，只能在原字符串上修改；
可以通过反转全部字符串，再反转每个单词，达到效果；
具体解题思路：

• 移除多余空格
• 将整个字符串反转
• 将每个单词反转

举个例子，源字符串为："the sky is blue "

• 移除多余空格 : “the sky is blue”
• 字符串反转：“eulb si yks eht”
• 单词反转：“blue is sky the”

移除多余空格的代码，如果直接使用erase，时间复杂度有些高，因此可以使用双指针来实现移除空格：

class Solution {
public:
    void removeExtraSpace(string& s)
    {
        //定义快慢指针
        int fast = 0;
        int slow = 0;
        //移除前面的多余空格
        while(s[fast] == ' ')
        {
            fast++;
        }

        //移除单词之间的多余空格
        for(; fast < s.size(); fast++)
        {
            if(fast > 0 && s[fast] == ' ' && s[fast - 1] == ' ') // 如果这是连续的第二个空格
            {
                continue;
            }
            s[slow] = s[fast];
            slow++;
        }
        //此时的字符串长度是slow
        //移除最后的多余空格，最后的空格一定只有一个了
        if(s[s.size() - 1] == ' ')
        {
            s.resize(slow - 1);
        }
        else
        {
            s.resize(slow);
        }
    }

    void reverseString(string& s, int begin, int end)
    {
        while(begin < end)
        {
            swap(s[begin], s[end]);
            begin++;
            end--;
        }
    }

    string reverseWords(string s) {
        removeExtraSpace(s);
        reverseString(s, 0, s.size() - 1);
        int pos = 0;
        for(int i = 0; i < s.size(); i++)
        {
            if(s[i] == ' ')
            {
                reverseString(s, pos, i - 1);
                pos = i + 1;
            }
        }
        reverseString(s, pos, s.size() - 1);

        return s;
    }
};