目录
1.4 Leetcode151 反转字符串里的单词
1.5 剑指Offer58-II.左旋转字符串
1.6 Leetcode28 找出字符串中第一个匹配项的下标(KMP 算法）
1.7 Leetcode459 重复的子字符串
Day 8
1.1 Leetcode 344 反转字符串
思路：对于字符串，我们定义两个指针（也可以说是索引下标），一个从字符串前面，一个从字符串后面，两个指针同时向中间移动，并交换元素。
代码：
//首尾双指针对换:时间复杂度O(n)，空间复杂度O（1）
void reverseString(vector<char>& s) {
int left=0;
int right=s.size()-1;
char temp;
while(left<right)//相等位置不用对换
{
temp=s[left];
s[left]=s[right];
s[right]=temp;
left++;//记得移动指针
right--;
}
return;//加不加这个都行
}
1.2 Leetcode541 反转字符串
题目：每2k个字符（k<n<2k也一样），前k个反转；不足k个时，全部反转
建议看方法2；方法1繁琐
思路：在遍历字符串的过程中，只要让 i += (2 * k)，i 每次移动 2 * k 就可以了，然后判断是否需要有反转的区间。因为要找的也就是每2 * k 区间的起点，这样写，程序会高效很多。
所以当需要固定规律一段一段去处理字符串的时候，要想想在在for循环的表达式上做做文章。
//方法1：我的思路，各种情况讨论，小于k,大于k小于2k，大于2k时再单独讨论
string reverseStr(string s, int k) {
if(s.size()<k)
{
reverse(s.begin(),s.end());
return s;
}
else if(s.size()>=k&&s.size()<2*k)
{
reverse(s.begin(),s.begin()+k);
return s;
}
else
{
reverse(s.begin(),s.begin()+k);//首先反转前k个
int size=s.size()-2*k;//把前2k个去掉
int left=2*k;//反转起点右移2k个位置,初始是0+2*k
while(size>0)//只要还有一个元素就反转
{
if(size<k)
{
reverse(s.begin()+left,s.end());//起点到终点
}
else
{
reverse(s.begin()+left,s.begin()+left+k);//起点到 起点+k
}
size=size-2*k;//每次循环后size减去2*k,看size大小
left=left+2*k; // 反转起点右移2k个位置
}
return s;
}
}
//方法2：代码随想录思路，直接for循环遍历，每一次i=i+2*k即可
string reverseStr(string s, int k)
{
for(int i=0;i<s.size();i=i+2*k)// 注意这里是size,不是下标
{
if(s.size()<i+k)//如0+k这里表示个数，不是下标，代表s里剩余不足k个数
{
reverse(s.begin()+i,s.end());//每次起始位置是begin()+i，需要全部反转
}
else//只需反转前k个
{
reverse(s.begin()+i,s.begin()+i+k);
}
}
return s;
}
1.3 剑指offer05 替换空格
//方法1：新建一个string
string replaceSpace(string s) {
string str;
for(int i=0;i<s.size();i++)
{
if(s[i]!=' ')
{
str+=s[i];
}
else
{
str+="%20";
}
}
return str;
}
//方法2：利用replace函数，在原有string上改造
string replaceSpace(string s) {
for(int i=0;i<s.size();i++)
{
//cout<<s[i]<<" ";
if(s[i]==' ')
{
s.replace(i,1,"%20");替换从pos开始n个字符为字符串str
// cout<<s.size()<<"_ ";//加入之后size立马变了，下一位是2，但也不影响
}
}
return s;
}
1.4 Leetcode151 反转字符串里的单词
//方法1：我的思路，新建一个string和vector<string>
string reverseWords(string s) {
string str;
vector<string> v;
for(int i=0;i<s.size();i++)
{
if(s[i]!=' ')
{
str+=s[i];
}
else
{
if(!str.empty())//前导和中间空格情况
{
v.push_back(str);
str.clear();//清空str
}
}
}
//跳出循环时会漏掉一个str没加入vector,当然也可能为空，此时属于尾随空格情况
if(!str.empty())
{
v.push_back(str);
str.clear();//清空继续使用
}
//从后往前遍历，重新生成字符串，
for(int i=v.size()-1;i>=0;i--)
{
if(i!=0)//不到最后一个
{
str+=v[i]+" ";//加空格
}
else
{
str+=v[i];//不用加空格
}
}
return str;
}
方法2：代码随想录题解，空间复杂度O（1）
思路：
- 移除多余空格
- 将整个字符串反转
- 将每个单词反转
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; //整体思想参考https://programmercarl.com/0027.移除元素.html
for (int i = 0; i < s.size(); ++i) { //
if (s[i] != ' ') { //遇到非空格就处理，即删除所有空格。
if (slow != 0) s[slow++] = ' '; //手动控制空格，给单词之间添加空格。slow != 0说明不是第一个单词，需要在单词前添加空格。（可以看到最后每个单词前都有空格，除了第一个单词）
while (i < s.size() && s[i] != ' ') { //补上该单词，遇到空格说明单词结束。
s[slow++] = s[i++];
}
}
}
s.resize(slow); //slow的大小即为去除多余空格后的大小。因为最后slow多加了一个，所以等于size大小了
}
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;
}
};
1.5 剑指Offer58-II.左旋转字符串
//方法1：第一思路，左旋就是把前n个字符移动到尾部，但要注意n>s.size()的情况，此时是循环左移,但多转几圈跟0圈情况一样
/*string reverseLeftWords(string s, int n) {
n=n%s.size();//防止n>s.size()情况，多转几圈跟0圈情况一样
string str;//新建一个string,空间复杂度O(n)
for(int i=n;i<s.size();i++)//先把n个后面的字符串加进来
{
str+=s[i];
}
for(int i=0;i<n;i++)
{
str+=s[i];
}
return str;
}*/
//方法2：以前见过的一种方法，试着做一下，先整体反转，再前（size-n）个反转，再后面n个反转，空间复杂度O(1)
/*string reverseLeftWords(string s, int n) {
reverse(s.begin(),s.end());
reverse(s.begin(),s.begin()+s.size()-n);//前闭后开
reverse(s.begin()+s.size()-n,s.end());
return s;
}*/
//方法3：代码随想录跟方法2类似，只是反转顺序不太一样，1.反转区间为前n的子串 2.反转区间为n到末尾的子串 3.反转整个字符串
string reverseLeftWords(string s, int n) {
reverse(s.begin(), s.begin() + n);
reverse(s.begin() + n, s.end());
reverse(s.begin(), s.end());
return s;
}
Day 9
1.6 Leetcode28 找出字符串中第一个匹配项的下标(KMP 算法）
//方法1：暴力BF法
/*int strStr(string haystack, string needle) {
if(needle.size()==0)
{
return 0;
}
int i=0;
int j=0;
while(i<haystack.size()&&j<needle.size())
{
if(haystack[i]==needle[j])//匹配上，继续比较下一位
{
i++;
j++;
}
else//不相等时回退，如果一开始不相等呢
{
i=i-j+1; //走了j步，回退到i-j+1
j=0;//j回退到初始位置
}
}
if(j>=needle.size())//说明比较完needle一遍了,Q且前面都相等
{
return i-needle.size();//走完了一个needle长度
}
else//说明haystack先遍历到头了
{
return -1;
}
}*/
//KMP 算法：好难懂呀！！
void getNext(int* next, const string& s)
{
//定义两个指针i和j，j指向前缀末尾位置，i指向后缀末尾位置。
int j=0;
next[0]=0;//next数组的第一个值永远为0，因为此时一个字符 没有前缀
for(int i=1;i<s.size();i++)//遍历模式串，求取每个i点的next[i],从1开始，next[0]已经知道了
{
while(j>0&&s[j]!=s[i])
{
j=next[j-1]; //向前回退
//这里不相等，代表j这个前缀末尾和i这个后缀末尾不一样，也就是说最长公共前后缀不能增加（加一）了。此时只能退而求其次，看前面的最长公共前后缀加1行不
}
if(s[j]==s[i])
{
j++;//最大公共前后缀长度加1，i++在for循环里了
}
next[i]=j;//j多加了一步，所以j就等于前缀长度了; 将j（前缀的长度）赋给next[i]
}
}
int strStr(string haystack, string needle) {
if(needle.size()==0)
{
return 0;
}
int next[needle.size()];
getNext(next,needle);
int j=0;
for(int i=0;i<haystack.size();i++)
{
while(j>0&&needle[j]!=haystack[i])
{
j=next[j-1];
}
if(needle[j]==haystack[i])
{
j++;
}
if(j>=needle.size())//如果j遍历完needle了，证明成功了，因为遇到不一样的，j会一直回退
{
return i-(needle.size()-1);//i少走了一步，因为for在外面
}
}
return -1;
}
1.7 Leetcode459 重复的子字符串
题干：给定一个非空的字符串 s ，检查是否可以通过由它的一个子串重复多次构成。
//方法1：暴力法，不知道由几个重复字符组成，假定重复的字符串为k个，k取值范围为1~n/2, n=s.size();
bool repeatedSubstringPattern(string s) {
int n=s.size();
for(int k=1;k<=n/2;k++)
{
if(n%k==0)//等于0才有可能组成，不等于0，说明重复的不能组成这个字符串
{
bool match=true;
for(int j=k;j<n;j++)
{
if(s[j]!=s[j-k])//j和j-k字符相同，因为每隔k个字符重复
{
match=false;
break;//说明不可能由（现在的k值） 个重复字符组成
}
}
if(match==true)//当k取某个值时，j循环能循环到底，说明符合条件
{
return true;
}
}
}
return false;
}
//方法2：字符串如果由重复的字符串组成，那么这个字符串本身相加，比如会在中间出现完全等于这个字符串的 字符串，如abc abcabc abc;但要注意掐头去尾
bool repeatedSubstringPattern(string s) {
string t=s+s;
t.erase(t.begin());
t.erase(t.end()-1);
if(t.find(s)!=-1)//能找到
{
return true;
}
return false;
}
//方法3：KMP算法，待研究
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
