8.反转字符串里的单词、右旋转字符串、实现substr、重复的子字符串

翻转字符串里的单词（leetcode第151题）

题目

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

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

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

**注意：**输入字符串 s中可能会存在前导空格、尾随空格或者单词间的多个空格。返回的结果字符串中，单词间应当仅用单个空格分隔，且不包含任何额外的空格。

思路

我的思路是维护快慢指针，遇到空格就在快慢指针之间进行反转；

这样想是审题出错了，是单词颠倒，不是每个单词的字母颠倒

不过在完成上面的条件下，进行整个字符串翻转并进行空格去重就行了

class Solution {
public:
    string reverseWords(string s) {
        int left=0;
        int right=0;
        for(int i=0;i<s.size();i++){
            if(i>0&&s[i-1]==' '&&s[i]!=' '){
                left=i;
            }
            if(i<s.size()-1&&s[i]!=' '&&s[i+1]==' '||s[i]!=' '&&i==s.size()-1){
                right=i;
            }
            while(left<right){
                char tmp=s[left];
                s[left]=s[right];
                s[right]=tmp;
                left++;
                right--;
            }
        }
        left=right=0;
        int head=1;
        for(int i=0;i<s.size();i++){
            
            if(head&&s[i]==' '||i>0&&s[i]==' '&&s[i-1]==' ')continue;
            head=0;
            s[left++]=s[i];
        }
        if(s[left-1]==' ')left--;
        s.resize(left);
        left=right=0;
        
       for(int i=0;i<s.size()/2;i++){
        char temp=s[i];
        s[i]=s[s.size()-1-i];
        s[s.size()-1-i]=temp;
       }
        return s;
    }
};

先去重，再整体反转

对比反思

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

右旋字符串（卡玛网第55题）

题目

题目描述

字符串的右旋转操作是把字符串尾部的若干个字符转移到字符串的前面。给定一个字符串 s 和一个正整数 k，请编写一个函数，将字符串中的后面 k 个字符移到字符串的前面，实现字符串的右旋转操作。

例如，对于输入字符串 “abcdefg” 和整数 2，函数应该将其转换为 “fgabcde”。

输入描述

输入共包含两行，第一行为一个正整数 k，代表右旋转的位数。第二行为字符串 s，代表需要旋转的字符串。

输出描述

输出共一行，为进行了右旋转操作后的字符串。

输入示例

2
abcdefg

输出示例

fgabcde

提示信息

数据范围：
1 <= k < 10000,
1 <= s.length < 10000;

附加条件：不适应额外空间

思路

我的想法是就不断往后挤，字符串多长就挤多少次；

当k是字符串长度的因子时就不行，可以分情况讨论；

#include 
#include 
using namespace std;
int main(){
    int k;
    int n;
    cin>>k;
	string s;
    cin>>s;
   
    n=s.size();
    k=k%n;
    char tmp=' ';
    int index=0;
    if(n%k){
        
        for(int i=0;i<n+1;i++){
            char temp=s[index];
            s[index]=tmp;
            tmp=temp;
            index=(index+k)%n;
        }
    }else{
        int div=n/k;
        for(int i=0;i<k+1;i++){
            index=(index+1)%n;
            for(int j=0;j<div+1;j++){
                char temp=s[index];
                s[index]=tmp;
                tmp=temp;
                index=(index+k)%n;
            }
        }
    }
    
    cout<<s;
}

但是oj过不去

对比反思

可以分成两部分，先整体反转，再局部反转

#include
#include
using namespace std;
int main() {
    int n;
    string s;
    cin >> n;
    cin >> s;
    int len = s.size(); //获取长度
    reverse(s.begin(), s.begin() + len - n); // 先反转前一段，长度len-n ，注意这里是和版本一的区别
    reverse(s.begin() + len - n, s.end()); // 再反转后一段
    reverse(s.begin(), s.end()); // 整体反转
    cout << s << endl;

}

实现 strStr()(leetcode第28题)

题目

给你两个字符串 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 。

提示：

• 1 <= haystack.length, needle.length <= 104
• haystack 和 needle 仅由小写英文字符组成

思路

这题要用kmp，kmp笔记见这篇

class Solution {
public:
    int strStr(string haystack, string needle) {
        //计算next
        int* next=new int[needle.size()];
        next[0]=0;
        int len=0;
        
        for(int i=1;i<needle.size();i++){
            while(len>0&&needle[i]!=needle[len]){
                len=next[len-1];
            }
            if(needle[i]==needle[len]){
                len++;
            }
            next[i]=len;
        }
        int j=0;
        int start=0;
        
        for(int i=0;i<haystack.size();i++){
            if(j==0){
                start=i;
            }else if(j>=needle.size()){
                return start;
            }
            if(needle[j]==haystack[i]){
                j++;
            }else if(j>0){
                int tmp=j;
                j=next[j-1];
                i--;
                tmp=tmp-j;
                start+=tmp;
            }
        }
        if(j>=needle.size()){
                return start;
        }
        return -1;
    }
};

重复的字串（leetcode第459题）

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

示例 1:

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

示例 2:

输入: s = "aba"
输出: false

示例 3:

输入: s = "abcabcabcabc"
输出: true
解释: 可由子串 "abc" 重复四次构成。 (或子串 "abcabc" 重复两次构成。)

提示：

• 1 <= s.length <= 104
• s 由小写英文字母组成

思路

感觉是只要最大相同前后缀的长度大于一半，就是true

写的时候发现并非如此，而是如果等于一半则一定是；小于则一定不是；大于则对前缀进行递归判断；

class Solution {
public:
    bool repeatedSubstringPattern(string s) {
        int *next=new int[s.size()];
        next[0]=0;
        int len=0;
        for(int i=1;i<s.size();i++){
            while(len>0&&s[i]!=s[len]){
                len=next[len-1];
            }
            if(s[i]==s[len]){
                len++;
            }
            next[i]=len;
        }
        int maxlen=next[s.size()-1];
        string sub=s.substr(0,maxlen);
        if(maxlen+maxlen==s.size())return 1;
        else if(maxlen+maxlen>s.size())return repeatedSubstringPattern(sub);
        return 0;
        
    }
};

对比反思

https://programmercarl.com/0459.%E9%87%8D%E5%A4%8D%E7%9A%84%E5%AD%90%E5%AD%97%E7%AC%A6%E4%B8%B2.html#%E6%80%9D%E8%B7%AF