2022.1.28 LeetCode总结

---

一、今日刷题

1. 第二部分：字符串 – 剑指 Offer 05. 替换空格

反转字符串
跳转LeetCode

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

示例 1：

输入：s = “We are happy.”
输出：“We%20are%20happy.”

答案代码：
正向遍历，原地修改。

package String;

/**
 * @author: LYZ
 * @date: 2022/1/28 13:46
 * @description: 剑指 Offer 05. 替换空格: 请实现一个函数，把字符串 s 中的每个空格替换成"%20"。
 */
public class ReplaceSpace {
    public static void main(String[] args) {
        ReplaceSpace replaceSpace = new ReplaceSpace();
        String ans = replaceSpace.replaceSpace("We are happy.");
        System.out.println(ans);
    }

    public String replaceSpace(String s) {
        StringBuffer stringBuffer = new StringBuffer(s);
        StringBuffer ans = new StringBuffer();
        for (int i = 0; i < stringBuffer.length(); i++) {
            if(stringBuffer.charAt(i) == ' ') {
                ans.append('%');
                ans.append('2');
                ans.append('0');
            } else {
                ans.append(stringBuffer.charAt(i));
            }
        }
        return ans.toString();
    }
}

2. 第二部分：字符串 – 第28题.实现 strStr()

跳转LeetCode

实现 strStr() 函数。

给你两个字符串 haystack 和 needle ，请你在 haystack 字符串中找出 needle 字符串出现的第一个位置（下标从 0 开始）。如果不存在，则返回 -1 。

说明：

当 needle 是空字符串时，我们应当返回什么值呢？这是一个在面试中很好的问题。

对于本题而言，当 needle 是空字符串时我们应当返回 0 。这与 C 语言的 strstr() 以及 Java 的 indexOf() 定义相符。

示例 1：

输入：haystack = “hello”, needle = “ll”
输出：2
示例 2：

输入：haystack = “aaaaa”, needle = “bba”
输出：-1

答案代码：

方法①：暴力匹配
我们可以让字符串needle 与字符串 haystack 的所有长度为 m 的子串均匹配一次。

为了减少不必要的匹配，我们每次匹配失败即立刻停止当前子串的匹配，对下一个子串继续匹配。如果当前子串匹配成功，我们返回当前子串的开始位置即可。如果所有子串都匹配失败，则返回 -1。

package String;

/**
 * @author: LYZ
 * @date: 2022/1/28 15:08
 * @description: 28.实现strStr()函数。
 * 给你两个字符串haystack 和 needle ，请你在 haystack 字符串中找出 needle 字符串出现的第一个位置（下标从 0 开始）。如果不存在，则返回 -1 。
 */
public class ImplementstrStr {
    public static void main(String[] args) {
        ImplementstrStr implementstrStr = new ImplementstrStr();
        int ans = implementstrStr.strStr("hello", "ll");
        System.out.println(ans);
    }

    public int strStr(String haystack, String needle) {
        int n = haystack.length();
        int m = needle.length();
        for (int i = 0; i + m <= n; i++) {
            boolean flag = true;
            for (int j = 0; j < m; j++) {
                if (haystack.charAt(i + j) != needle.charAt(j)) {
                    flag = false;
                    break;
                }
            }
            if (flag) {
                return i;
            }
        }
        return -1;
    }
}

方法②：KMP算法
跳转B站讲解

class Solution {
    public int strStr(String text, String pattern) {
        if(text == null || pattern == null){
            return -1;
        }
        if(pattern.length() == 0){
            return 0;
        }
        // 首先得到前缀表
        // 前缀表是一个一维数组，数组的下标表示遍历pattern的指针位置(j),数组的值表示当pattern的指针j和text的指针i对应的字符内容不同时(坏字符),j指针需要移动
        // 到pattern的位置
        int[] next = getNext(pattern);
        // 定义两个指针，i用来遍历text，j用来遍历pattern
        int i = 0;
        int j = 0;
        char[] charsT = text.toCharArray();
        char[] charsP = pattern.toCharArray();
        while(j < charsP.length && i < charsT.length){
            // 当指针i和j位置上的元素不匹配时，需要将j指针通过next数组移动到指定位置上
            if(charsT[i] != charsP[j]){
                j = next[j];
                // 如果j等于-1，说明j指针已经pattern的最前面了，并且已经没有共有字符串了，直接将j指针和i指针同时往后移动一位j++
                // 这里就能体现将next[0]设置成-1的巧妙了，这样j++，i++的时候就意味着把text当做一个全新的字符串，除去了[0,i)之前的元素，j=0也从pattern
                // 的起始位置开始匹配
                if(j == -1){
                  i++;
                  j++;
                }
            }else{
                //如果匹配上，那就正常进行下一个字符的匹配
                i++;
                j++;
            }
        }
        // 循环结束后，如果j和pattern长度相同，说明全部匹配完了，也就是在text中找到了第一次出现pattern的位置，这时候i指针已经到了pattern字符位置的最后一个字符的位置
        // 起始位置需要减掉pattern的长度
        if(j == charsP.length){
            return i - j;
        }
        return -1;
    }

    public int[] getNext(String pattern){
        // 先求出字符串的前缀表
        char[] charArr = pattern.toCharArray();
        int[] next = new int[charArr.length];
        // 因为字符串的第一个元素没有前后缀，所以共有最大字符串长度为0
        next[0] = 0;
        int len = 0;
        int i = 1;
        /*
            i   str          next[i]
            0   A            0
            1   AB           0
            2   ABA          1
            3   ABAB         2
            4   ABABC        0
            5   ABABCA       1
            6   ABABCAB      2
            7   ABABCABA     3
            8   ABABCABAA    1
        */
        while (i < charArr.length){
            // 1.举例：比如这次进来的字符串是上面的AB,此时上一次的共有字符串长度是len=0(因为上一次就一个A字符，没有共有字符串，当然是0)，
            // 要想判断这次共有字符串长度会不会加1，只需要判断这次的字符串AB比上次字符串A多出来的字符(也就是B)是不是和上次共有字符串长度位置上的字符相等
            // 也就是charArr[1(i)] == charArr[0(len)]?，这里是不等，所以不能加1
            // 2.比如这次进来的是ABA，上一次是AB，那么多出来的这个A和上次AB的共有字符串长度位置(len=0)上的字符是否相等，显然charArr[0] == charArr[2]，所以len++;
            // 3.再比如：这次进来的是ABAB,上一次是ABA,上一次的共有字符串长度是len=1，判断这次多出来的字符B是不是和charArr[1]相等，显然相等，len++;
            if(charArr[i] == charArr[len]){
                len++;
                next[i] = len;
                i++;
            }else{
                // 如果不相等，说明这次多出来的这个字符并没有让共有字符串的长度加1，而且，可能还会直接影响到上一次的共有字符串长度
                // 这里的做法是：因为多出来一个字符，而且charArr[i] != charArr[len]，那这次已经不能拿上一次共有字符串位置上的字符来做比较了，必须拿上上一次的结果
                // 比如：这次进来的是ABABC,上一次是ABAB，上一次共有字符串是AB,len=2,那charArr[2(len)]是A，和这次的多出来的C已经不一样了，那上次的len已经不能作为判断依据了，
                // 必须拿上上一次的len,于是i不变，也就是说下一轮循环还是ABABC，但是len要拿上上一轮的长度，也就是AB这个字符串共有字符串的长度值，len=1，
                // 此时charArr[1(len)]是B，还是和C不相同，说明这次的len还是不能作为判断，于是i继续不变，下一轮还是ABABC，len拿A的共有字符串长度值，len=0，
                // 此时charArr[0(len)]是A，还是和C不相同，说明这次的len还是不能作为判断，理论上还得去那更早一次的len值，但是这时候有个临界情况，因为已经拿到第一次进来的len了，
                // len拿不到更早一次的值了，或者说到这已经没有共有字符串了，说明这次加多出来的字符C。彻底让这个字符串ABABC没有了共有字符串，也就是len=0，可以放心的将这一轮字符串
                // 的共有字符串长度设为0了，这轮len值设置完毕，i++，进行下一轮设置
                if(len > 0){
                    len = next[len-1];
                }else{
                    next[i] = len;
                    i++;
                }
            }
        }
        // 到此，前缀表已经设置完毕，但是有个问题，就是next[0]和next[1]的位置一直都是0，为了后续使用的方便，需要将""和只有一个字符的字符串共有前缀区别开，
        // 而且，对共有字符串来说，前缀表的最后一项就是字符串本身的共有字符串长度，这个在实际使用的时候没有意义，所以直接将整个前缀表往后平移一位，空出来的
        // next[0]赋值为-1
        for (int j = next.length  -1; j > 0; j--) {
            next[j] = next[j-1];
        }
        next[0] = -1;
//        for (int m = 0; m < next.length; m++) {
//            System.out.print(next[m] + "");
//        }
        return next;
    }
}

二、知识积累：

1.strStr（）函数：

strstr(str1,str2) 是C语言中的一种库函数，用于判断字符串str2是否是str1的子串。如果是，则该函数返回 str1字符串从 str2第一次出现的位置开始到 str1结尾的字符串；否则，返回NULL。

实例：

#include <stdio.h>
#include <string.h>
 
 
int main()
{
   const char haystack[20] = "RUNOOB";
   const char needle[10] = "NOOB";
   char *ret;
 
   ret = strstr(haystack, needle);
 
   printf("子字符串是： %s\n", ret);
   
   return(0);
}

2.字符串的前缀与后缀：

前缀：包含首字母，但不包含末尾字母的所有子串。
如aabaaf的所有前缀：

a
aa
aab
aaba
aabaa

后缀：包含末尾字母，但不包含首字母的所有子串。
如aabaaf的所有后缀：

f
af
aaf
baaf
abaaf