字符串
文章目录
1.反转字符串
344. 反转字符串
编写一个函数，其作用是将输入的字符串反转过来。输入字符串以字符数组 s 的形式给出。
不要给另外的数组分配额外的空间，你必须**原地修改输入数组**、使用 O(1) 的额外空间解决这一问题。
1.reverse函数
class Solution {
public:
void reverseString(vector<char>& s) {
reverse(s.begin(),s.end());
}
};
2.普通方法
class Solution {
public:
void reverseString(vector<char>& s) {
if(s.size() == 1)return;
for(int i = 0,j = s.size() - 1;i < s.size()/2;i++,j--){
swap(s[i],s[j]);
/*char temp = s[i];
s[i] = s[j];
s[j] = temp;*/
}
}
};
2.反转字符串
541. 反转字符串 II
给定一个字符串 s 和一个整数 k，从字符串开头算起，每计数至 2k 个字符，就反转这 2k 字符中的前 k 个字符。
- 如果剩余字符少于
k个，则将剩余字符全部反转。 - 如果剩余字符小于
2k但大于或等于k个，则反转前k个字符，其余字符保持原样。
1.普通for
class Solution {
public:
string reverseStr(string s, int k) {
for(int i = 0;i < s.size() - 1;i = i + 2 * k){
if(i + k < s.size()){
for(int j = i,l = i + k - 1;j < k/2 + i;j++,l--){
swap(s[j],s[l]);
}
}
else{
for(int j = i,l = s.size() - 1;j < l;j++,l--){
swap(s[j],s[l]);
}
}
}
return s;
}
};
2.reverse函数
class Solution {
public:
string reverseStr(string s, int k) {
for(int i = 0;i < s.size() - 1;i = i + 2 * k){
if(i + k < s.size()){
reverse(s.begin() + i,s.begin() + i + k);
}
else{
reverse(s.begin() + i,s.end());
}
}
return s;
}
};
3.替换空格
剑指 Offer 05. 替换空格
请实现一个函数，把字符串 s 中的每个空格替换成"%20"。
就是实现replace功能，不要直接用replace；
1.普通方法
class Solution {
public:
string replaceSpace(string s) {
string ss;
for(int i = 0;i < s.size();i++){
if(s[i] == ' '){
ss =ss + '%' + '2' + '0';
}
else{
ss += s[i];
}
}
return ss;
}
};
2.根据代码随想录，先将空间拓展，再从后放字符
class Solution {
public:
string replaceSpace(string s) {
int count = 0;
int oldSize = s.size();
for(int i = 0;i < s.size();i++){
if(s[i] == ' ')count++;
}
s.resize(s.size() + 2 * count);
int newSize = s.size();
for(int i = newSize - 1,j = oldSize - 1;i >= 0;j--){
if(s[j] != ' '){
s[i] = s[j];
i--;
}
else{
s[i] = '0';
s[i - 1] = '2';
s[i - 2] = '%';
i = i - 3;
}
}
return s;
}
};
4.反转字符串里的单词
151. 反转字符串中的单词
给你一个字符串 s ，请你反转字符串中 单词 的顺序。
单词 是由非空格字符组成的字符串。s 中使用至少一个空格将字符串中的 单词 分隔开。
返回 单词 顺序颠倒且 单词 之间用单个空格连接的结果字符串。
**注意：**输入字符串 s中可能会存在前导空格、尾随空格或者单词间的多个空格。返回的结果字符串中，单词间应当仅用单个空格分隔，且不包含任何额外的空格。
1.暴力，没考虑空间
class Solution {
public:
string reverseWords(string s) {
string ss;
for(int i = 0,j = 0;i < ss.size(),j < s.size();j++){
if(j == 0 && s[j] == ' ') {
i++;
continue;
}
else if(j > 0 && s[j] == ' ' && s[j - 1] == ' '){
i++;
continue;
}
else if(j > 0 && s[j] == ' ' && s[j - 1] != ' '){
string str = s.substr(i,j - i);
ss = ' ' + str + ss;
i = j + 1;
}
else if(j == s.size() - 1 && s[j] != ' '){
string str = s.substr(i,j - i + 1);
ss = ' ' + str + ss;
}
}
ss.erase(0,1);//减去开头的空格
return ss;
}
};
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]);
}
}
string reverseWords(string s) {
//去多余空格
int slow = 0 ,fast = 0;
for(;fast < s.size();fast++){
if(fast == 0 && s[fast] == ' ')continue;
else if(fast > 0 && s[fast] == ' ' && s[fast - 1] == ' ')continue;
else if(fast == s.size() - 1 && s[fast] == ' ')continue;
else{
s[slow] = s[fast];
slow++;
}
}
if(s[slow - 1] == ' '){
s.resize(slow - 1);//结尾空格会被加上去
}
else s.resize(slow);//重新规划大小空间
reverse(s,0,s.size() - 1);//全部反转
for(int end = 0,start = 0;end <= s.size();end++){
if(s[end] == ' ' || end == s.size()){
reverse(s,start,end - 1);
start = end + 1;
}
}
return s;
}
};
5.左旋转字符串
剑指 Offer 58 - II. 左旋转字符串
字符串的左旋转操作是把字符串前面的若干个字符转移到字符串的尾部。请定义一个函数实现字符串左旋转操作的功能。比如，输入字符串"abcdefg"和数字2，该函数将返回左旋转两位得到的结果"cdefgab"。
1.普通方法
class Solution {
public:
string reverseLeftWords(string s, int n) {
string str = s.substr(0,n);
s.erase(0,n);
s += str;
return s;
}
};
2.O(1)空间
class Solution {
public:
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;
}
};
6.实现 strStr()
28. 找出字符串中第一个匹配项的下标
给你两个字符串 haystack 和 needle ，请你在 haystack 字符串中找出 needle 字符串的第一个匹配项的下标（下标从 0 开始）。如果 needle 不是 haystack 的一部分，则返回 -1 。
1.暴力for
2.kmp算法
前缀减一
class Solution {
public:
//前缀表-1
void getNext(string& needle,int* next){
int j = -1;
next[0] = j;
for(int i = 1;i < needle.size();i++){
while(j >= 0 && needle[i] != needle[j + 1]){
//不匹配
j = next[j];
}
if(needle[i] == needle[j + 1]){
//匹配
j++;
}
next[i] = j;
}
}
int strStr(string haystack, string needle) {
int next[needle.size()];
getNext(needle,next);
int j = -1;
for(int i = 0;i < haystack.size();i++){
while(j >= 0 && haystack[i] != needle[j + 1]){
j = next[j];
}
if(haystack[i] == needle[j + 1]){
//匹配，下标加一
j++;
}
if(j == needle.size() - 1){
return (i - j);
}
}
return -1;
}
};
3.前缀不减
class Solution {
public:
//前缀不减
void getNext(string& s,vector<int>& next){
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];
}
if(s[i] == s[j]){
j++;
}
next[i] = j;
}
}
int strStr(string haystack, string needle) {
vector<int> next(needle.size());
getNext(needle,next);
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 - j + 1);
}
}
return -1;
}
};
7.重复匹配字符串
459.重复的子字符串
给定一个非空的字符串 s ，检查是否可以通过由它的一个子串重复多次构成。
1.暴力for
class Solution {
public:
bool repeatedSubstringPattern(string s) {
bool pan = false;
if(s.size() == 1)return false;
for(int slow = 0,fast = 1;fast < s.size();fast++){
if(s[slow] == s[fast] && s.size()%(fast - slow) == 0){
for(int i = slow,j = fast;i < fast;i++,j++){
if(s[i] != s[j]){
pan = false;
break;
}
else pan = true;
}
if(pan == true){
int n = slow;
slow = fast;
fast = fast + (fast - n) - 1;
if(fast + 1 < s.size() && s[slow] != s[fast + 1]){
slow = 0;
pan = false;
}
}
}
}
return pan;
}
};
2.移动匹配(太精妙了，代码随想录上的)
class Solution {
public:
bool repeatedSubstringPattern(string s) {
if(s.size() == 1)return false;
string str = s + s;//如果字符串重复，把两个字符串连在一起，去头去尾，还能找到一样的字符串(非两个连接其中一个)
str.erase(str.begin());
str.erase(str.end() - 1);
if(str.find(s) != string::npos)return true;
return false;
}
};
*3.kmp(数学推导)
class Solution {
public:
void kmp(string& s,int *next){
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];
}
//匹配
if(s[i] == s[j]){
j++;
}
next[i] = j;
}
}
bool repeatedSubstringPattern(string s) {
int next[s.size()];
kmp(s,next);
int len = s.size();
if(next[len - 1] != 0 && len % (len - next[len - 1]) == 0)return true;
return false;
}
};