【代码随想录】【字符串】

344. 反转字符串

编写一个函数，其作用是将输入的字符串反转过来。输入字符串以字符数组 s 的形式给出。

不要给另外的数组分配额外的空间，你必须原地修改输入数组、使用 O(1) 的额外空间解决这一问题。

思路

定义两个指针（也可以说是索引下标），一个从字符串前面，一个从字符串后面，两个指针同时向中间移动，并交换元素。

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

541. 反转字符串 II

给定一个字符串 s 和一个整数 k，从字符串开头算起，每计数至 2k 个字符，就反转这 2k 字符中的前 k 个字符。

如果剩余字符少于 k 个，则将剩余字符全部反转。
如果剩余字符小于 2k 但大于或等于 k 个，则反转前 k 个字符，其余字符保持原样。

思路

每次移动2*K个区间，再判断区间大小实现相应规则的反转效果

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(s.begin() + i, s.begin() + i + k );
            } else {
                // 3. 剩余字符少于 k 个，则将剩余字符全部反转。
                reverse(s.begin() + i, s.end());
            }
        }
        return s;
    }
};

剑指 Offer 05. 替换空格※

请实现一个函数，把字符串 s 中的每个空格替换成"%20"。

思路

首先扩充数组到每个空格替换成"%20"之后的大小，然后用双指针法从后向前替换空格。
优点：1、不用申请新数组。2、从后向前填充元素，避免了从前向后填充元素时，每次添加元素都要将添加元素之后的所有元素向后移动的问题。

class Solution {
public:
    string replaceSpace(string s) {
        int cnt = 0;
        //统计空格数量
        for(int i = 0; i<s.size(); i++)
        {
            if(s[i] == ' ')
                cnt++;
        }
        //字符串扩展(默认参数为0，即NULL或者'\0')。
        int left = s.size()-1;
        s.resize(s.size()+2*cnt);
        //从后往前双指针替换
        int right = s.size()-1;
        
        while(left!=right)
        {
            if(s[left]!=' ')
            {
                s[right] = s[left];
                right--;
                left--;
            }
            else
            {
                s[right] = '0';
                right--;
                s[right] = '2';
                right--;
                s[right] = '%';
                right--;
                left--;
            }
        }
        return s;
    }
};

151. 反转字符串中的单词

给你一个字符串 s ，请你反转字符串中 单词 的顺序。

单词 是由非空格字符组成的字符串。s 中使用至少一个空格将字符串中的 单词 分隔开。

返回 单词 顺序颠倒且 单词 之间用单个空格连接的结果字符串。

注意：输入字符串 s中可能会存在前导空格、尾随空格或者单词间的多个空格。返回的结果字符串中，单词间应当仅用单个空格分隔，且不包含任何额外的空格。
示例 1：
输入：s = “the sky is blue”
输出：“blue is sky the”
示例 2：
输入: " hello world! "
输出: “world! hello”
解释: 输入字符串可以在前面或者后面包含多余的空格，但是反转后的字符不能包括。
示例 3：
输入: “a good example”
输出: “example good a”
解释: 如果两个单词间有多余的空格，将反转后单词间的空格减少到只含一个。

思路

1、使用一些常用的库函数

size_type find( const basic_string& str, size_type pos = 0 ) const;

参数:
str - 要搜索的 string ， pos - 开始搜索的位置
返回值
找到的子串的首字符位置，或若找不到这种子串则为 npos 。

basic_string substr( size_type pos = 0, size_type count = npos ) const;

参数:
pos - 要包含的首个字符的位置 ，count - 子串的长度
返回值
含子串 [pos, pos+count) 的 string 。

char* strtok( char* str, const char* delim );

参数:
str - 指向要记号化的空终止字节字符串的指针
delim - 指向标识分隔符的空终止字节字符串的指针
返回值:
指向下个记号起始的指针，或若无更多记号则为空指针。

在第一次调用时，strtok()必需给予参数str字符串，往后的调用则将参数str设置成NULL。每次调用成功则返回下一个分割后的字符串指针。
返回下一个分割后的字符串指针，如果已无从分割则返回NULL。
代码示例：

#include <string>
#include "stdio.h"

int main ()
{
    char str[] ="a,b,c,d*e";
    const char * split = ",";
    char * p;
    p = strtok (str,split);
    while(p!=NULL) {
        printf ("%s\n",p);
        p = strtok(NULL,split);
    } 

    return 0;
}

2、使用 O(1) 额外空间复杂度的 原地 解法
使用双指针法来去移除空格，最后resize（重新设置）一下字符串的大小，就可以做到O(n)的时间复杂度。

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的大小即为去除多余空格后的大小。
    }

    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;
    }
};

剑指 Offer 58 - II. 左旋转字符串

字符串的左旋转操作是把字符串前面的若干个字符转移到字符串的尾部。请定义一个函数实现字符串左旋转操作的功能。比如，输入字符串"abcdefg"和数字2，该函数将返回左旋转两位得到的结果"cdefgab"。

思路

1、额外空间+库函数substr

class Solution {
public:
    string reverseLeftWords(string s, int n) {
        string newstr;
        newstr+=s.substr(n, s.size()-n);
        newstr+=s.substr(0, n);
        return newstr;
    }
};

2、原地reverse
局部反转+整体反转

• 反转区间为前n的子串
• 反转区间为n到末尾的子串
• 反转整个字符串

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;
    }
};

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

28. 找出字符串中第一个匹配项的下标※

给你两个字符串 haystack 和 needle ，请你在 haystack 字符串中找出 needle 字符串的第一个匹配项的下标（下标从 0 开始）。如果 needle 不是 haystack 的一部分，则返回 -1 。

思路

1、库函数/暴力解

class Solution {
public:
    int strStr(string haystack, string needle) {
        if(haystack.find(needle,0) != haystack.npos)
            return haystack.find(needle,0);
        else
            return -1;

    }
};

class Solution {
public:
    int strStr(string haystack, string needle) {
        int nee=0;
        bool flag=0;
        if (needle.empty()) {
            return 0;
        }
        for(int i = 0; i<haystack.size(); i++)
        {
            if(haystack[i]==needle[nee])
            {
                flag=1;
                for(int j = i; j<i+needle.size(); j++)
                {
                    if(haystack[j]!=needle[nee]){
                        flag=0;
                        break;
                    }
                    nee++;
                }
                if(flag)
                    return i;
            }
            nee=0;
        }
        return -1;
    }
};

2、KMP

next的构建好难想清楚，这是什么？再看一眼！这是什么？再看一眼！这是什么？再看一眼！这是什么？再看一眼！这是什么？再看一眼！：https://programmercarl.com/0028.%E5%AE%9E%E7%8E%B0strStr.html#%E6%80%9D%E8%B7%AF

KMP主要应用在字符串匹配上。KMP的经典思想就是:当出现字符串不匹配时，可以记录一部分之前已经匹配的文本内容，利用这些信息避免从头再去做匹配。
next数组就是一个前缀表（prefix table）。（也可以是前缀表统一减一（右移一位，初始位置为-1）。）
前缀表：记录下标i之前（包括i）的字符串中，有多大长度的相同前缀后缀。
前缀是指不包含最后一个字符的所有以第一个字符开头的连续子串。
后缀是指不包含第一个字符的所有以最后一个字符结尾的连续子串。

令n为文本串长度，m为模式串长度，因为在匹配的过程中，根据前缀表不断调整匹配的位置，可以看出匹配的过程是O(n)，之前还要单独生成next数组，时间复杂度是O(m)。所以整个KMP算法的时间复杂度是O(n+m)的。

暴力的解法显而易见是O(n × m)，所以KMP在字符串匹配中极大地提高了搜索的效率。

前缀表统一减一代码：

class Solution {
public:
//构建next数组
    void getNext(int* next, const string& s) {
        int j = -1;
        next[0] = j;
        for(int i = 1; i < s.size(); i++) { // 注意i从1开始
            while (j >= 0 && s[i] != s[j + 1]) { // 前后缀不相同了
                j = next[j]; // 向前回退
            }
            if (s[i] == s[j + 1]) { // 找到相同的前后缀
                j++;
            }
            next[i] = j; // 将j（前缀的长度）赋给next[i]
        }
    }
    int strStr(string haystack, string needle) {
        if (needle.size() == 0) {
            return 0;
        }
        int next[needle.size()];
        getNext(next, needle);
        //使用next数组匹配
        int j = -1; // // 因为next数组里记录的起始位置为-1
        for (int i = 0; i < haystack.size(); i++) { // 注意i就从0开始
            while(j >= 0 && haystack[i] != needle[j + 1]) { // 不匹配
                j = next[j]; // j 寻找之前匹配的位置
            }
            if (haystack[i] == needle[j + 1]) { // 匹配，j和i同时向后移动
                j++; // i的增加在for循环里
            }
            if (j == (needle.size() - 1) ) { // 文本串s里出现了模式串t
                return (i - needle.size() + 1);
            }
        }
        return -1;
    }
};

459. 重复的子字符串※

给定一个非空的字符串 s ，检查是否可以通过由它的一个子串重复多次构成。
示例 1:

输入: s = “abab”
输出: true
解释: 可由子串 “ab” 重复两次构成。

思路

1、移动匹配
判断字符串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)

2、KMP
假设字符串s使用多个重复子串构成（这个子串是最小重复单位），重复出现的子字符串长度是x，所以s是由n * x组成。

因为字符串s的最长相同前后缀的长度一定是不包含s本身，所以 最长相同前后缀长度必然是m * x，而且 n - m = 1，（这里如果不懂，看上面的推理）

所以如果 nx % (n - m)x = 0，就可以判定有重复出现的子字符串。
如果len % (len - (next[len - 1] + 1)) == 0 ，则说明数组的长度正好可以被 (数组长度-最长相等前后缀的长度) 整除 ，说明该字符串有重复的子字符串。

数组长度减去最长相同前后缀的长度相当于是第一个周期的长度，也就是一个周期的长度，如果这个周期可以被整除，就说明整个数组就是这个周期的循环。

前缀表统一减一代码：

class Solution {
public:
    void getNext(int* next, const string& str)
    {
        int j = -1;//前缀末尾
        next[0] = j;
        for(int i = 1; i < str.size(); i++)//后缀末尾
        {
            //不相同回退
            while(j>=0 && str[i]!=str[j+1])
                j = next[j];
            //相同
            if(str[i] == str[j+1]){
                j++;
            }
            next[i] = j;
        }
    }
    bool repeatedSubstringPattern(string s)
    {
        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;
    }
};

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