代码随想录算法训练营第9天
代码随想录
28. 实现 strStr()
实现 strStr() 函数。
给定一个 haystack 字符串和一个 needle 字符串,在 haystack 字符串中找出 needle 字符串出现的第一个位置 (从0开始)。如果不存在,则返回 -1。
示例 1: 输入: haystack = “hello”, needle = “ll” 输出: 2
示例 2: 输入: haystack = “aaaaa”, needle = “bba” 输出: -1
说明: 当 needle 是空字符串时,我们应当返回什么值呢?这是一个在面试中很好的问题。 对于本题而言,当 needle 是空字符串时我们应当返回 0 。这与C语言的 strstr() 以及 Java的 indexOf() 定义相符。
思路:
暴力法:
public int strStrB(String haystack, String needle) {
if(needle==null || needle.length()==0){
return 0;
}
if(haystack.length()<needle.length()){
return -1;
}
int hayLen = haystack.length();
int needleLen = needle.length();
for(int i = 0;i <= hayLen - needleLen;i++){
int j;
for(j=0;j<needleLen;j++){
if(haystack.charAt(i+j)!=needle.charAt(j)){
break;
}
}
if(j==needleLen){
return i;
}
}
return -1;
}
力扣上的简单解法:
public int strStrA(String haystack, String needle) {
int i = haystack.indexOf(needle);
return i;
}
KMP算法
KMP的经典思想就是:当出现字符串不匹配时,可以记录一部分之前已经匹配的文本内容,利用这些信息避免从头再去做匹配。
流程:
1、构造next数组
初始化->处理前后缀不相同的情况->处理前后缀相同的情况->更新next数组
i-> 后缀末尾 j->前缀末尾
若前后缀不匹配,则j回退到next数组前一位的值对应的位置 j=next[j-1]
2、文本串与模式串进行比配
遇到不匹配的则进行回退 回退到next[j-1] ;j==needle.length 时说明两个字符串匹配到了
public int strStr(String haystack, String needle) {
if(needle==null){
return 0;
}
if(needle.length()>haystack.length()){
return -1;
}
int[] next = getNext(needle);
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;
}
//查找next数组
public int[] getNext(String s){
//初始化
int[] next = new int[s.length()];
int j =0; //后缀末尾
next[0]=0;
// i 前缀末尾
for(int i =1;i<s.length();i++){
//前后缀不相同
while(j>0&&s.charAt(i)!=s.charAt(j)){
j=next[j-1];
}
if(s.charAt(i)==s.charAt(j)){
j++;
}
next[i]=j;
}
return next;
}
●459.重复的子字符串
给定一个非空的字符串,判断它是否可以由它的一个子串重复多次构成。给定的字符串只含有小写英文字母,并且长度不超过10000。
示例 1:
输入: “abab”
输出: True
解释: 可由子字符串 “ab” 重复两次构成。
示例 2:
输入: “aba”
输出: False
示例 3:
输入: “abcabcabcabc”
输出: True
解释: 可由子字符串 “abc” 重复四次构成。 (或者子字符串 “abcabc” 重复两次构成。)
思路:暴力法:
public boolean repeatedSubstringPattern(String s) {
if(s.length()<1) return false;
char[] ch = s.toCharArray();
int k = 1;
int n = ch.length;
for(int i =1;i<=n/2;i++){
if(n%i==0){
String sub = s.substring(0, i);
StringBuilder sb = new StringBuilder();
for(int j=0;j<n/i;j++){
sb.append(sub);
}
if(sb.toString().equals(s)){
return true;
}
}
}
return false;
}
移动匹配
substring 函数可以更方便地实现获取子字符串的功能。
public boolean repeatedSubstringPattern(String s) {
// abacabac
String str = s + s;
// bacaba 去掉首尾
return str.substring(1, str.length() - 1).contains(s);
}
KMP
如果 next[len - 1] != -1,则说明字符串有最长相同的前后缀(就是字符串里的前缀子串和后缀子串相同的最长长度)
如果len % (len - (next[len - 1] + 1)) == 0 ,则说明数组的长度正好可以被 (数组长度-最长相等前后缀的长度) 整除 ,说明该字符串有重复的子字符串。
数组长度减去最长相同前后缀的长度相当于是第一个周期的长度,也就是一个周期的长度,如果这个周期可以被整除,就说明整个数组就是这个周期的循环。
public boolean repeatedSubstringPattern(String s) {
if(s.equals("")) return false;
int[] next = new int[s.length()];
char[] chars = s.toCharArray();
int len = s.length();
getNext(next,s);
if(next[len-1]>0 && len%(len-next[len-1])==0){
return true;
}
return false;
}
public void getNext(int[] next,String s) {
//初始化
int j = 0; //前缀末尾 i--后缀末尾
next[0] = 0;
//前缀后缀不相等 回退
for (int i = 1; i < s.length(); i++) {
// 前后缀不相等 回退
while (j > 0 && s.charAt(j) != s.charAt(i)) {
//回退到前一位下标所对应的位置
j = next[j - 1];
}
//前缀后缀相等
if (s.charAt(i) == s.charAt(j)) {
j++;
}
//更新next
next[i] = j;
}
}