算法Day8|字符串专题二剑指 Offer 58 - II. 左旋转字符串，28. 找出字符串中第一个匹配项的下标，459. 重复的子字符串

本文链接：https://blog.csdn.net/Road_slow/article/details/127666718

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

解题思路：

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

class Solution {
   public String reverseLeftWords(String s, int n) {
        StringBuilder sb = new StringBuilder(s);
        reverse(sb, 0, n - 1);//反转区间为前n的子串
        reverse(sb, n, s.length()- 1);//反转区间为n到末尾的子串
        reverse(sb, 0, s.length()- 1);//反转整个字符串
        return sb.toString();
    }

    public void reverse(StringBuilder sb, int left, int right) {
        while (left < right) {
            char temp = sb.charAt(left);
            sb.setCharAt(left,sb.charAt(right));
            sb.setCharAt(right, temp);
            left++;
            right--;
        }
    }
}

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

1.解题思路(KMP算法)：

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

1.1.next数组的作用

next数组就是一个前缀表（prefix table）。

前缀表有什么作用呢？

前缀表是用来回退的，它记录了模式串与主串(文本串)不匹配的时候，模式串应该从哪里开始重新匹配。

为了清楚的了解前缀表的来历，我们来举一个例子：

要在文本串：aabaabaafa 中查找是否出现过一个模式串：aabaaf。

请记住文本串和模式串的作用，对于理解下文很重要，要不然容易看懵。所以说三遍：

要在文本串：aabaabaafa 中查找是否出现过一个模式串：aabaaf。

要在文本串：aabaabaafa 中查找是否出现过一个模式串：aabaaf。

要在文本串：aabaabaafa 中查找是否出现过一个模式串：aabaaf。

如动画所示：

可以看出，文本串中第六个字符b 和模式串的第六个字符f，不匹配了。如果暴力匹配，会发现不匹配，此时就要从头匹配了。

但如果使用前缀表，就不会从头匹配，而是从上次已经匹配的内容开始匹配，找到了模式串中第三个字符b继续开始匹配。

此时就要问了前缀表是如何记录的呢？

首先要知道前缀表的任务是当前位置匹配失败，找到之前已经匹配上的位置，再重新匹配，此也意味着在某个字符失配时，前缀表会告诉你下一步匹配中，模式串应该跳到哪个位置。

那么什么是前缀表：记录下标i之前（包括i）的字符串中，有多大长度的相同前缀后缀。

1.2.前缀和后缀

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

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

1.3.前缀表的思想

回顾一下，刚刚匹配的过程在下标5的地方遇到不匹配，模式串是指向f，如图：

然后就找到了下标2，指向b，继续匹配：如图：

以下这句话，对于理解为什么使用前缀表可以告诉我们匹配失败之后跳到哪里重新匹配非常重要！

重点：

1.下标5之前这部分的字符串（也就是字符串aabaa）的前缀有{a,aa,aab,aaba}，后缀有{a,aa,baa,abaa}。

2.字符串aabaa的最长相等的前缀和后缀字符串是子字符串aa 。

3.因为找到了最长相等的前缀和后缀，匹配失败的位置是后缀子串的后面，那么我们找到与其相同的前缀的后面从新匹配就可以了。

1.4.求前缀表

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

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

1.字符串a的前缀有0，后缀有0。最长相同前后缀的长度为0。

1.字符串aa的前缀有{a}，后缀有{a}。最长相同前后缀的长度为1。

3.字符串aab的前缀有{a,aa}，后缀有{b,ab}。最长相同前后缀的长度为0。

4.字符串aaba的前缀有{a,aa,aab}，后缀有{a,ba,aba}。最长相同前后缀的长度为1。

4.字符串aabaa的前缀有{a,aa,aab,aaba}，后缀有{a,aa,baa,abaa}。最长相同前后缀的长度为2。

5.字符串aabaaf的前缀有{a,aa,aab,aaba,aabaa}，后缀有{f,af,aaf,baaf,abaaf}。最长相同前后缀的长度为0。

1.5.前缀表与next数组

next数组就可以是前缀表，但是很多实现都是把前缀表统一减一（右移一位，初始位置为-1）之后作为next数组。

为什么这么做呢，其实也是很多文章视频没有解释清楚的地方。

其实这并不涉及到KMP的原理，而是具体实现，next数组即可以就是前缀表，也可以是前缀表统一减一（右移一位，初始位置为-1）。

1.6.实现next数组

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

初始化
处理前后缀不相同的情况
处理前后缀相同的情况

初始化：定义两个指针j，j指向前缀末尾位置，i指向后缀末尾位置。

然后还要对next数组进行初始化赋值，如下

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

2.处理前后缀不相同的情况

因为j初始化为0，那么i就从1开始，进行array[i] 与 array[j+1]的比较。

所以遍历模式串s的循环下标i 要从 1开始，代码如下：

 for (int i = 1; i < n; i++) {

}

那么 array[i] 与 array[j] 不相同，就要找 j前一个元素在next数组里的值（就是next[j-1]）。

所以，处理前后缀不相同的情况代码如下：

while (j > 0 && array[j] != array[i]) {
    j = next[j - 1];
}

3.处理前后缀相同的情况

如果 array[i] 与 array[j] 相同，那么就同时向后移动i 和j 说明找到了相同的前后缀，同时还要将j（前缀的长度）赋给next[i], 因为next[i]要记录相同前后缀的长度。

代码如下：

 if (array[j] == array[i]) {
        j++;
 }
 next[i] = j;

最后整体构建next数组的函数代码如下：

   public void getNext(String needle, int[] next) {
        int j = 0, n = needle.length();
        next[0] = j;
        char[] array = needle.toCharArray();
        // 注意i从1开始
        for (int i = 1; i < n; i++) {
            // 前后缀不相同了
            while (j > 0 && array[j] != array[i]) j = next[j - 1];// 向前回退
            if (array[j] == array[i]) j++;// 找到相同的前后缀
            next[i] = j;// 将j（前缀的长度）赋给next[i]
        }
    }

2.28题解

class Solution {
   public int strStr(String haystack, String needle) {
        if (needle.length() == 0) {
            return -1;
        }
        int[] next = new int[needle.length()];
        getNext(needle, next);
        int j = 0;
        for (int i = 0; i < haystack.length(); i++) {
            while (j > 0 && haystack.charAt(i) != needle.charAt(j)) {
                j = next[j - 1];
            }
            if (haystack.charAt(i) == needle.charAt(j)) {
                j++;
            }
            if (j == needle.length()) {
                return i - needle.length() + 1;
            }
        }
        return -1;
    }

    public void getNext(String needle, int[] next) {
        int j = 0, n = needle.length();
        next[0] = j;
        char[] array = needle.toCharArray();
        for (int i = 1; i < n; i++) {
            while (j > 0 && array[j] != array[i]) j = next[j - 1];
            if (array[j] == array[i]) j++;
            next[i] = j;
        }
    }
}

459. 重复的子字符串

1.解题思路（KMP算法）：

KMP算法中next数组为什么遇到字符不匹配的时候可以找到上一个匹配过的位置继续匹配，靠的是有计算好的前缀表。前缀表里，统计了各个位置为终点字符串的最长相同前后缀的长度。

在由重复子串组成的字符串中，最长相等前后缀不包含的子串就是最小重复子串，这里那字符串s：abababab 来举例，ab就是最小重复单位，如图所示：

1.1 如何找到最小重复子串

步骤一：因为这是相等的前缀和后缀，t[0] 与 k[0]相同， t[1] 与 k[1]相同，所以 s[0] 一定和 s[2]相同，s[1] 一定和 s[3]相同，即：，s[0]s[1]与s[2]s[3]相同。

步骤二：因为在同一个字符串位置，所以 t[2] 与 k[0]相同，t[3] 与 k[1]相同。

步骤三：因为这是相等的前缀和后缀，t[2] 与 k[2]相同，t[3]与k[3] 相同，所以，s[2]一定和s[4]相同，s[3]一定和s[5]相同，即：s[2]s[3] 与 s[4]s[5]相同。

步骤四：循环往复。

所以字符串s，s[0]s[1]与s[2]s[3]相同， s[2]s[3] 与 s[4]s[5]相同，s[4]s[5] 与 s[6]s[7] 相同。

正是因为最长相等前后缀的规则，当一个字符串由重复子串组成的，最长相等前后缀不包含的子串就是最小重复子串。

数组长度为：n。

1.如果n % (n - (next[n - 1] )) == 0 ，则说明数组的长度正好可以被 (数组长度-最长相等前后缀的长度) 整除，说明该字符串有重复的子字符串。

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

数组长度为：n=8。

next[n-1] = 6，6就是此时字符串abababab的最长相同前后缀的长度。

(len - (next[n - 1])) 也就是： 8(字符串的长度) - 6(最长公共前后缀的长度) = 2， 2正好可以被8(字符串的长度) 整除，所以说明有重复的子字符串（ab）。

2.459题解

class Solution {
   //459. 重复的子字符串
    public boolean repeatedSubstringPattern(String s) {
        int n = s.length();
        if (n == 0) {
            return false;
        }
        int[] next = new int[n];
        getNext(s, next);
        if (next[n - 1] != 0 && n % (n - next[n - 1]) == 0) {
            return true;
        }
        return false;
    }
    public void getNext(String needle, int[] next) {
        int j = 0, n = needle.length();
        next[0] = j;
        char[] array = needle.toCharArray();
        for (int i = 1; i < n; i++) {
            while (j > 0 && array[j] != array[i]) j = next[j - 1];
            if (array[j] == array[i]) j++;
            next[i] = j;
        }
    }
}