力扣打卡day08

字符串专项

344. 反转字符串

class Solution {
    public void reverseString(char[] s) {
        int left=0;
        int right=s.length-1;
        while(left<right){
            char temp=s[left];
            s[left]=s[right];
            s[right]=temp;
            left++;
            right--;
        }
    }
}

541. 反转字符串 II

class Solution {
    public String reverseStr(String s, int k) {
        char[] ch=s.toCharArray();
        // 1. 每隔 2k 个字符的前 k 个字符进行反转
        for(int i=0;i<ch.length;i+=2*k){
            // 2. 剩余字符小于 2k 但大于或等于 k 个，则反转前 k 个字符
            //区间一般为左闭又开
            if(i+k<=ch.length){
                reverse(ch,i,i+k-1);
                //因为对尾部的处理写在下面了，如果这个循环成功，则不执行尾部处理
                continue;
            }
            // 3. 剩余字符少于 k 个，则将剩余字符全部反转
            reverse(ch, i, ch.length - 1);
        }
        return new String(ch);
    }
    public void reverse(char[] ch,int i,int j){
        for(;i<j;i++,j--){
            char temp=ch[i];
            ch[i]=ch[j];
            ch[j]=temp;
        }
    }
}

剑指 Offer 05. 替换空格

class Solution {
    public String replaceSpace(String s) {
        if(s.length()==0||s==null){
            return s;
        }
        //由于需要字符串的拼接所以用StringBuilder
        StringBuilder str=new StringBuilder();
        for(int i=0;i<s.length();i++){
            if(s.charAt(i)==' '){
                str.append("  ");
            }
        }
        if(str.length()==0){
            return s;
        }
        int left=s.length()-1;
        s+=str.toString();
        int right=s.length()-1;
        char[] ch=s.toCharArray();
        while(left>=0){
            if(ch[left]==' '){
                ch[right--]='0';
                ch[right--]='2';
                ch[right]='%';
            }else{
                ch[right]=ch[left];
            }
            left--;
            right--;
        }
        return new String(ch);
    }
}

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

class Solution {
    public String reverseLeftWords(String s, int n) {
        char[] ch=s.toCharArray();
        reverseString(ch,0,n-1);
        reverseString(ch,n,ch.length-1);
        reverseString(ch,0,ch.length-1);
        return new String(ch);
    }
    public void reverseString(char[] ch,int i,int j){
        for(;i<j;i++,j--){
            char temp=ch[i];
            ch[i]=ch[j];
            ch[j]=temp;
        }
    }
}

28. 找出字符串中第一个匹配项的下标
KMP算法（解决字符串匹配问题）
其中n为文本串长度，m为模式串长度，因为在匹配的过程中，根据前缀表不断调整匹配的位置，可以看出匹配的过程是O(n)，之前还要单独生成next数组，时间复杂度是O(m)。所以整个KMP算法的时间复杂度是O(n+m)的。

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

KMP的主要思想是当出现字符串不匹配时，可以知道一部分之前已经匹配的文本内容，可以利用这些信息避免从头再去做匹配了。
next数组就是一个前缀表（prefix table）。
前缀表是用来回退的，它记录了模式串与主串(文本串)不匹配的时候，模式串应该从哪里开始重新匹配。
前缀表：记录下标i之前（包括i）的字符串中，有多大长度的相同前缀后缀。
最长相等前后缀？
前缀是指不包含最后一个字符的所有以第一个字符开头的连续子串。

后缀是指不包含第一个字符的所有以最后一个字符结尾的连续子串。

因为前缀表要求的就是相同前后缀的长度。
举例
文本串 aabaabaaf
模式串 aabaaf
前缀表010120
找到的不匹配的位置， 那么此时我们要看它的前一个字符的前缀表的数值是多少。

为什么要前一个字符的前缀表的数值呢，因为要找前面字符串的最长相同的前缀和后缀。

所以要看前一位的 前缀表的数值。前一个字符的前缀表的数值是2， 所有把下标移动到下标2的位置继续比配。

前缀表与next数组
next数组就可以是前缀表，但是很多实现都是把前缀表统一减一（右移一位，初始位置为-1）之后作为next数组。并不涉及到KMP的原理，而是具体实现，next数组即可以就是前缀表，也可以是前缀表统一减一（右移一位，初始位置为-1）。

class Solution {
    //前缀表（不减一）Java实现
    public int strStr(String haystack, String needle) {
        if (needle.length() == 0) return 0;
        int[] next = new int[needle.length()];
        getNext(next, needle);

        int j = 0;
        for (int i = 0; i < haystack.length(); i++) {
            while (j > 0 && needle.charAt(j) != haystack.charAt(i)) //不匹配
                j = next[j - 1];//j寻找之前匹配的位置
            if (needle.charAt(j) == haystack.charAt(i)) //匹配
                j++;//i和j同时向后移动
            if (j == needle.length()) //找到了
                return i - needle.length() + 1;
        }
        return -1;

    }
    
    private void getNext(int[] next, String s) {
        int j = 0;//前缀的末尾位置
        next[0] = 0;
        for (int i = 1; i < s.length(); i++) {
            while (j > 0 && s.charAt(j) != s.charAt(i)) 
                //i和j不相等的时候j要向前回退，看j前一位的next值为其回退的位置
                j = next[j - 1];
            if (s.charAt(j) == s.charAt(i)) 
                j++;
            next[i] = j; 
        }
    }
}

459. 重复的子字符串

class Solution {
    public boolean repeatedSubstringPattern(String s) {
        String t=s.concat(s);
        int start=1;
        int end=t.length()-1;
        String str=t.substring(start,end);
        if(str.contains(s)){
            return true;
        }
        return false;
    }
}