leetcode--字符串

344 反转字符串

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

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

class Solution {
    public void reverseString(char[] s) {
        int len =  s.length;
        for(int i = 0, j = len - 1; i < len / 2; i++, j--){
            char temp = s[i];
            s[i] = s[j];
            s[j] = temp;
        }
        
    }
}

剑指 Offer 05. 替换空格

请实现一个函数，把字符串 s 中的每个空格替换成"%20"。
采用StringBuilder，直接复制s。

class Solution {
    public String replaceSpace(String s) {
        //使用一个新的对象，复制str，在复制的过程中对其进行判断，是空格则替换，反之则直接复制
        if(s == null){
            return null;
        }

        //选用StringBuilder 单线程使用，比较快
        StringBuilder sb = new StringBuilder();
        //通过sb直接复制s
        for(int i = 0; i < s.length(); i++){
            if(s.charAt(i) == ' '){
                sb.append("%20");
            }else{
                sb.append(s.charAt(i));
            }
        }

        return sb.toString();
    }
}

151. 反转字符串中的单词

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

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

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

注意：输入字符串 s中可能会存在前导空格、尾随空格或者单词间的多个空格。返回的结果字符串中，单词间应当仅用单个空格分隔，且不包含任何额外的空格。
分析：这道题还是有点难度的。我们可以分三步来走。第一步：首先将字符串头和尾的空格去掉，采用removeSpace(String s)方法；第二步：将整个字符串进行翻转；第三步：将字符串的每一个单词进行反转，这个步骤的实现步骤主要是以空格为目标，发现空格，就知道了该单词的末位和下一个单词的起始位置。

class Solution {
    public String reverseWords(String s) {
        StringBuilder sb = removeSpace(s);

        reverseString(sb, 0, sb.length() - 1);

        reverseEachWord(sb);

        return sb.toString();
    }

    private  StringBuilder removeSpace(String s){
        int start = 0;
        int end = s.length() - 1;
        while(s.charAt(start) == ' ') start++;
        while(s.charAt(end) == ' ') end--;
        StringBuilder sb = new StringBuilder();
        while(start <= end){
            char c = s.charAt(start);
            if(c != ' ' || sb.charAt(sb.length() - 1) != ' '){
                sb.append(c);
            }
            start++;
        }
        return sb;
    }

    /**
    反转字符指定区间[start, end]的字符
     */
    
    public void reverseString(StringBuilder sb, int start, int end){
        while(start < end){
            //反转字符串
            char temp = sb.charAt(start);
            sb.setCharAt(start, sb.charAt(end));
            sb.setCharAt(end, temp);
            start++;
            end--;

        }
    }

    private void reverseEachWord(StringBuilder sb){
        int start = 0;
        int end = 1;
        int n = sb.length();
        while(start < n){
            while(end < n && sb.charAt(end) != ' '){
                end++;
            }
            reverseString(sb, start, end - 1);
            start = end + 1;
            end = start + 1;
        }
    }
}

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

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

class Solution {
    public String reverseLeftWords(String s, int n) {
        int len = s.length();

        StringBuilder sb = new StringBuilder();
        for(int i = n; i < len; i++){
            sb.append(s.charAt(i));
        }
        for(int i = 0; i < n; i++){
            sb.append(s.charAt(i));
        }

        return sb.toString();
    }
}

第二种方法：要求只能在原来的字符串上操作，不能申请额外的空间
首先反转整个字符串
第二步翻转前len - 1 -n 个字符串
第三步反转第len-n到len - 1的字符串

注意：这里结果返回的是return new String(chars)

class Solution {
    public String reverseLeftWords(String s, int n) {
        char[] chars = s.toCharArray();
        int len = chars.length;

        reserse(chars, 0, len - 1);
        reserse(chars, 0, len - 1 - n);
        reserse(chars, len - n, len - 1);
        
        return new String(chars);
    }

    private void reserse(char[] chars, int left, int right){

        while(left < right){
            char temp = chars[left];
            chars[left] = chars[right]; 
            chars[right] = temp;
            left++;
            right--;
        }
    }
}

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

给你两个字符串 haystack 和 needle ，请你在 haystack 字符串中找出 needle 字符串的第一个匹配项的下标（下标从 0 开始）。如果 needle 不是 haystack 的一部分，则返回 -1 。
这道题是KMP经典题目
KMP主要应用在字符串匹配上

KMP的主要思想就是当出现字符串不匹配时，可以知道一部分之前已经匹配的文本内容，可以利用这些信息避免从头再去匹配了

最重要：next数组
next数组是一个前缀表（prefix table），其主要作用是用来回退的，它记录了模式串与主串（文本串）不匹配的时候，模式串应该从哪里开始重新匹配。
比如：
主串：aabaabaafa
子串：aabaaf

构造next数组，其实就是计算模式串s，前缀表的过程，主要分以下三步：

• 初始化
• 处理前后缀不相同的情况
• 处理前后缀相同的情况
  1、初始化
  定义两个指针i和j，j指向前缀末尾位置，i指向后缀末尾位置
  然后还要对next数组初始化

int j = -1;
next[0] = j;

next[i]表示i（包括i）之前最长相等的前后缀长度（其实就是j）
2、处理前后缀不相同的情况
因为j初始化为-1，那么i就从1开始，进行s[i]与s[j + 1]的比较。
所以遍历模式串s的循环下标i要从1开始，代码如下：

for(int i = 1; i < s.size(); i++){}

如果s[i]与s[j + 1]不相同，也就是遇到 前后缀末尾不相同的情况，就要向前回退。
怎么回退？
next[j]就记录这j（包括j）之前的字串的相同前后缀的长度。
那么s[i]与s[j+ 1]不相同，就要找j+1前一个元素在next数组里的值（就是next[j]）

总体代码

 class Solution {
    public int strStr(String haystack, String needle) {
        if(needle.length() == 0){
            return 0;
        }

        int[] next = new int[needle.length()];
        getNext(next, needle);

        int j = -1;
        for(int i = 0; i < haystack.length(); i++){
            while(j >= 0 && haystack.charAt(i) != needle.charAt(j + 1)){
                j = next[j];
            }
            if(haystack.charAt(i) == needle.charAt(j + 1)){
                j++;
            }
            if(j == needle.length() - 1){
                return(i - needle.length() + 1);
            }
        }

        return -1;
    }

    private void getNext(int[] next, String s){

        int j = -1;
        next[0] = j;
        for(int i = 1; i < s.length(); i++){
            while(j >= 0 && s.charAt(i) != s.charAt(j + 1)){//前后缀不相同
                j = next[j];//向前回退
            }
            if(s.charAt(i) == s.charAt(j + 1)){
                j++;
            }
            next[i] = j;
        }
    }
}

459. 重复的子字符串

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

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

class Solution {
    public boolean repeatedSubstringPattern(String s) {
        if(s.equals("")) return false;

        int len = s.length();

        //原串加个空格，使下标从1开始，这样j从0开始，也不用初始化了
        s = " " + s;
        int[] next = new int[len + 1];
        char[] chars = s.toCharArray();

        //构造next数组过程，j从0开始，i从2开始
        for(int i = 2, j = 0; i < len + 1; i++){
            while(j > 0 && chars[i] != chars[j + 1]){
                j = next[j];
            }
            if(chars[i] == chars[j + 1]){
                j++;
            }
            next[i] = j;
        }
        //最后判断是否重复的子字符串，这里next[len]即代表next数组末尾的值
        if(next[len] > 0 && len % (len - next[len]) == 0){
            return true;
        }

        return false;
    }
}