字符串

int转char

a = 1;char b = char(a+'0');

字符串转char*

 if(strstr(x,s[i].c_str()));

分割子串

 s.substr(pos, len)！！！

判断是否是子串

char x[12],y[12];
cin>>x>>y;
if(strstr(x,y))

写在前面，字符串string：s.size()，s.length()。向量vector：v.size()，字符串传参，，加&，string& s，这样直接传地址，避免了一次拷贝，快一丢丢。

344. 反转字符串 - 力扣（LeetCode） (leetcode-cn.com)

也是双指针思想，left和right两头开工，当然直接for循环，从头到中点，交换首尾值也是一样的思想。

class Solution {
public:
    void reverseString(vector<char>& s) {
        int right = s.size()-1,left = 0;
        while(left<right){
            char t = s[left];
            s[left] = s[right];
            s[right] = t;
            left++;
            right--;
        }
    }
};

swap函数碰巧又看到了，不定义新变量，位运算实现

举个栗子，a=1和b=2

01和10，a=a^b=11,b=b^a=01,a=a^b=10

完成交换

541. 反转字符串 II - 力扣（LeetCode） (leetcode-cn.com)

这道题学了reverse用法，左闭右开

反转整个字符串可以是：

reverse(s.begin(),s.end());

reverse(s.begin(),s.begin()+s.size());

反转下标从i开始长度为k的字符串

reverse(s.begin()+i,s.begin()+i+k);

s.resize(10);//截取10个长度  

s.resize(10,'b'); //空位填充字符b 

 

151. 翻转字符串里的单词 - 力扣（LeetCode） (leetcode-cn.com)

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 slowIndex = 0, fastIndex = 0; // 定义快指针，慢指针
        // 去掉字符串前面的空格
        while (s.size() > 0 && fastIndex < s.size() && s[fastIndex] == ' ') {
            fastIndex++;
        }
        while(fastIndex < s.size()) {
            // 去掉字符串中间部分的冗余空格
            if (fastIndex - 1 > 0
                    && s[fastIndex - 1] == s[fastIndex]
                    && s[fastIndex] == ' ') {//fastIndex放在这报错overflow
            } 
            else
               s[slowIndex++] = s[fastIndex];
            fastIndex++;
        }//while结束fastIndex=s.size(),如果末尾有空格，不管多少只会放入一个空格
        if (slowIndex - 1 > 0 && s[slowIndex - 1] == ' ') { // 去掉字符串末尾的空格
            s.resize(slowIndex - 1);
        } else {
            s.resize(slowIndex); // 重新设置字符串大小
        }
    }
    string reverseWords(string s) {
        removeExtraSpaces(s);
        reverse(s, 0, s.size() - 1);
        int left = 0;
        for(int i = 0; i < s.size(); i++) {
            if(s[i]==' '){
                reverse(s, left, i-1);
                left = i+1;
            }
        }
        reverse(s, left, s.size()-1);
        return s;
    }
};

 

KMP算法

next数组,j=0开始，表示的是i（包括i）之前最长相等的前后缀的长度

next数组,j=-1开始，表示的是i（包括i）之前最长相等的前后缀的位置（数组下标）

 

28. 实现 strStr() - 力扣（LeetCode） (leetcode-cn.com)

class Solution {
public:
    void getNext(int* next,const string &s){
         int j=-1;
         next[0]=j;
         for(int i=1;i<s.size();i++){
             while(j>=0&&s[i]!=s[j+1]){//j是-1，后面访问next[j]会出错
                     j=next[j];//next[j]表示j之前的字符串（包括j）的最大前后缀长度
                 }
             if(s[i]==s[j+1]){
                 j++;
             }
             next[i] = j;
         }

    }
    int strStr(string haystack, string needle) {
       if(needle.size()==0)
            return 0;
        int next[needle.size()];
        getNext(next,needle);
        int j=-1;
        for(int i=0;i<haystack.size();i++){
            while(j>=0&&haystack[i]!=needle[j+1]){//j是-1，后面访问next[j]会出错
                    j=next[j];//next[j]表示j之前的字符串（包括j）的最大前后缀位置
                }
            if(haystack[i]==needle[j+1]){
                j++;
            }
            if(j==(needle.size()-1))
                return i-needle.size()+1;
        }
        return -1;
    }
};

 

459. 重复的子字符串 - 力扣（LeetCode） (leetcode-cn.com)

class Solution {
public:
    void getNext(int *next,string s){
        int j=-1;
        next[0]=j;
        for(int i=1;i<s.size();i++){
            while(j>=0&&s[i]!=s[j+1])
                j=next[j];
            if(s[i]==s[j+1])
                j++;
            next[i]=j;
            //cout<<next[i];//输入asdasdasd   asdbbbasd
        }
    }
    bool repeatedSubstringPattern(string s) {
        if(s.size()==0)
            return false;
        int next[s.size()];
        getNext(next,s);
        int len = s.size();
        if(next[len-1]!=-1&&(len%(len-next[len-1]-1)==0)){//作差得出第一个重复子串的长度，也就是一个重复周期
            return true;
        }
        return false;
    }
};