目录
一、反转字符串
344. 反转字符串 - 力扣（LeetCode）
https://leetcode.cn/problems/reverse-string/description/
编写一个函数，其作用是将输入的字符串反转过来。输入字符串以字符数组 char[] 的形式给出。
不要给另外的数组分配额外的空间，你必须原地修改输入数组、使用 O(1) 的额外空间解决这一问题。
你可以假设数组中的所有字符都是 ASCII 码表中的可打印字符。
示例 1：
输入：["h","e","l","l","o"]
输出：["o","l","l","e","h"]
示例 2：
输入：["H","a","n","n","a","h"]
输出：["h","a","n","n","a","H"]# 写法一
class Solution {
public:
void reverseString(vector<char>& s) {
int left = 0, right = s.size() - 1;
while (left < right) {
int tmp = s[left];
s[left] = s[right];
s[right] = tmp;
left++;
right--;
}
}
};
# 写法二
class Solution {
public:
void reverseString(vector<char>& s) {
for (int i = 0, j = s.size() - 1; i < s.size()/2; i++, j--) {
swap(s[i],s[j]);
}
}
};二、反转字符串II
541. 反转字符串 II - 力扣（LeetCode）https://leetcode.cn/problems/reverse-string-ii/description/
给定一个字符串 s 和一个整数 k，从字符串开头算起, 每计数至 2k 个字符，就反转这 2k 个字符中的前 k 个字符。
- 如果剩余字符少于 k 个，则将剩余字符全部反转。
- 如果剩余字符小于 2k 但大于或等于 k 个，则反转前 k 个字符，其余字符保持原样。
示例 1：
输入：s = "abcdefg", k = 2
输出："bacdfeg"
示例 2：
输入：s = "abcd", k = 2
输出："bacd"class Solution {
public:
string reverseStr(string s, int k) {
for (int i = 0; i < s.size(); i += (2 * k)) {
// 1. 每隔 2k 个字符的前 k 个字符进行反转
// 2. 剩余字符小于 2k 但大于或等于 k 个，则反转前 k 个字符
if (i + k <= s.size()) {
// reverse 的 end 指向最后一个元素的下一个位置
reverse(s.begin() + i, s.begin() + i + k );
} else {
// 3. 剩余字符少于 k 个，则将剩余字符全部反转。
reverse(s.begin() + i, s.end());
}
}
return s;
}
};三、翻转字符串里的单词
151. 反转字符串中的单词 - 力扣（LeetCode）https://leetcode.cn/problems/reverse-words-in-a-string/description/
给定一个字符串，逐个翻转字符串中的每个单词。
示例 1：
输入: "the sky is blue"
输出: "blue is sky the"
示例 2：
输入: " hello world! "
输出: "world! hello"
解释: 输入字符串可以在前面或者后面包含多余的空格，但是反转后的字符不能包括。
示例 3：
输入: "a good example"
输出: "example good a"
解释: 如果两个单词间有多余的空格，将反转后单词间的空格减少到只含一个。思路：
- 移除多余空格
- 将每个单词反转
- 将整个字符串反转
1. 写法一
class Solution {
public:
string reverseWords(string s) {
// 同步把空格都处理掉+单词倒序
s = s + ' '; // 末尾增加一个空格
// 移动到第一个单词开头
while (s[0] == ' ') {
s.erase(0, 1);
}
// 遍历字符串
int left = 0, right = 0;
for (int i = 0; i < s.length(); i++) {
if (s[i] == ' ' && s[i - 1] == ' ') {
// 移除空格
s.erase(i--, 1);
}
else if(s[i] == ' ' && s[i - 1] != ' ') {
// 单词翻转
right = i - 1;
while (left < right) {
swap(s[left++], s[right--]);
}
}
if (s[i] == ' ' && s[i + 1] != ' ') {
// 移除完空格以后记录
left = i + 1;
}
}
// 删除最后一个空格
if (s[s.length() - 1] == ' ') {
s.erase(s.length() - 1, 1);
}
// 整个字符串翻转
left = 0;
right = s.length() - 1;
while (left < right) {
swap(s[left++], s[right--]);
}
return s;
}
};2. 写法二
class Solution {
public:
void reverse(string& s, int start, int end){ // 翻转
for (int i = start, j = end; i < j; i++, j--) {
swap(s[i], s[j]);
}
}
// 去除所有空格并在相邻单词之间添加空格, 快慢指针
void removeExtraSpaces(string& s) {
int slow = 0;
for (int i = 0; i < s.size(); ++i) { //
if (s[i] != ' ') { // 遇到非空格就处理，即删除所有空格。
if (slow != 0) {
// 手动控制空格，给单词之间添加空格
// slow != 0说明不是第一个单词，需要在单词前添加空格。
s[slow++] = ' ';
}
while (i < s.size() && s[i] != ' ') { // 补上该单词，遇到空格说明单词结束。
s[slow++] = s[i++];
}
}
}
s.resize(slow); //slow的大小即为去除多余空格后的大小。
}
string reverseWords(string s) {
removeExtraSpaces(s); // 去除多余空格，保证单词之间之只有一个空格，且字符串首尾没空格
reverse(s, 0, s.size() - 1);
int start = 0; // removeExtraSpaces 后保证第一个单词的开始下标一定是 0
for (int i = 0; i <= s.size(); ++i) {
if (i == s.size() || s[i] == ' ') { // 到达空格或者串尾，说明一个单词结束。进行翻转
reverse(s, start, i - 1); // 翻转，注意是左闭右闭 []的翻转
start = i + 1; // 更新下一个单词的开始下标 start
}
}
return s;
}
};四、实现 strStr()
实现 strStr() 函数。
给你两个字符串
haystack和needle，请你在haystack字符串中找出needle字符串的第一个匹配项的下标（下标从 0 开始）。如果needle不是haystack的一部分，则返回-1。
示例 1：
输入：haystack = "sadbutsad", needle = "sad"
输出：0
解释："sad" 在下标 0 和 6 处匹配。
第一个匹配项的下标是 0 ，所以返回 0 。
示例 2：
输入：haystack = "leetcode", needle = "leeto"
输出：-1
解释："leeto" 没有在 "leetcode" 中出现，所以返回 -1 。思路：（KMP算法）
可以跳转 代码随想录 的网站 代码随想录 (programmercarl.com) 查看本题思路，也可以 参考代码中的注释（个人理解）。
class Solution {
public:
void getNext(int* next, const string& s) {
// 求前缀表
int j = 0;
next[0] = 0;
for(int i = 1; i < s.size(); i++) {
// 处理前后缀不相等的情况
while (j > 0 && s[i] != s[j]) {
j = next[j - 1];
}
// i 表示后缀末尾，j 表示前缀末尾
// 前后缀相等的话，前缀可以向后+1，继续和 后缀向后+1 个字母进行比较
// 理解：
// (1)如果相等的话，最长相等前后缀 相当于 +1
// (2)不相等的话 后缀向后+1 个字母就和 前缀上次记录的字符下标（对后缀来说最长前缀字符串的最后一位）进行对比
// 两步进行循环
if (s[i] == s[j]) {
j++;
}
next[i] = j;
}
}
int strStr(string haystack, string needle) {
// KMP算法
if (needle.size() == 0) {
return 0;
}
vector<int> next(needle.size());
getNext(&next[0], needle);
int j = 0;
for (int i = 0; i < haystack.size(); i++) {
while(j > 0 && haystack[i] != needle[j]) {
j = next[j - 1];
}
if (haystack[i] == needle[j]) {
j++;
}
if (j == needle.size()) {
return (i - needle.size() + 1);
}
}
return -1;
}
};五、重复的子字符串
459. 重复的子字符串 - 力扣（LeetCode）https://leetcode.cn/problems/repeated-substring-pattern/description/
给定一个非空的字符串，判断它是否可以由它的一个子串重复多次构成。给定的字符串只含有小写英文字母，并且长度不超过10000。
示例 1:
输入: "abab"
输出: True
解释: 可由子字符串 "ab" 重复两次构成。
示例 2:
输入: "aba"
输出: False
示例 3:
输入: "abcabcabcabc"
输出: True
解释: 可由子字符串 "abc" 重复四次构成。 (或者子字符串 "abcabc" 重复两次构成。)思路：（KMP算法）
首先计算出前缀表。（这里和第四个题一样的思路，只是 next 整体 -1）
next[len - 1] = 7，next[len - 1] + 1 = 8，8 就是此时字符串 asdfasdfasdf 的最长相同 前后缀的长度。
(len - (next[len - 1] + 1))也就是： 12(字符串的长度) - 8(最长公共前后缀的长度) = 4， 为最长相同前后缀不包含的 子串长度。4 可以被 12(字符串的长度) 整除，所以说明有重复的子字符串（asdf）。
class Solution {
public:
vector<int> getNext(vector<int> next, const string s) {
for (int i = 1, j = 0; i < s.length(); i++) {
// 处理 i 当前位与 j 当前位不相等情况
while (j > 0 && s[i] != s[j]) {
j = next[j - 1];
}
// 子串长度增加
if (s[i] == s[j]) {
j++;
}
next[i] = j;
}
return next;
}
bool repeatedSubstringPattern(string s) {
// KMP 算法
vector<int> next(s.length(), 0);
// 获得前缀表
next = getNext(next, s);
for (int i = 0; i < next.size(); i++) {
cout << next[i] << ' ';
}
int len = s.length();
if (next[len - 1] != 0 && len % (len - (next[len - 1])) == 0) {
return true;
}
return false;
}
};
扫一扫
2475
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
