求最长重复子串的算法
public class StrTest {
@Test
public void longDoubSubStr(){
String str = "eabcdabcfeabeabeabeab";
String longDoubSubStr1 = findLongestSubString(str);
System.out.println("longDoubSubStr1:"+longDoubSubStr1);
String longDoubSubStr2 = findSubStr(str);
System.out.println("longDoubSubStr2:"+longDoubSubStr2);
String longDoubSubStr3 = findSubStrByNxt(str);
System.out.println("longDoubSubStr3:"+longDoubSubStr3);
}
private String findSubStrByNxt(String str) {
int maxPos = 0;
int maxReStrLen = 0;
/**
* 使用KMP算法：依次去掉str最前端的i个字符，计算余下子串的next[]数组，数组的最大指，即为最大子串长度，
* 并根据得到最大子串时的位置的i值，获取最大子串
*/
for (int pos = 0; pos < str.length(); pos++){
String subStrTem = str.substring(pos);
/**
*
*/
int reStrLen = calcNxtArry(subStrTem);
if (reStrLen > maxReStrLen){
maxReStrLen = reStrLen;
maxPos = pos;
}
}
/**
* 从maxSubStrLenSubInfo中解析出重复的最长子串信息
*/
return str.substring(maxPos, maxPos + maxReStrLen);
}
private int calcNxtArry(String subStrTem) {
int maxReStrLen = 0;
int reStrLen = 0;
int preIndexReStrLen = 0;
for (int index = 0; index < subStrTem.length(); index++){
reStrLen = getNxt(index, subStrTem, preIndexReStrLen);
if (maxReStrLen < reStrLen){
maxReStrLen = reStrLen;
}
preIndexReStrLen = reStrLen;
}
return maxReStrLen;
}
private int getNxt(int index, String subStrTem, int preIndexReStrLen) {
int subStrLen = 0;
if (index == 0){
return 0;
}
/**
* 以下的逻辑可以优化：
* 1）记录前一index对应的preindex_subStrLen，subStrLen = preindex_subStrLen +1 开始循环
*/
// for(subStrLen = index; subStrLen > 0; subStrLen--){
// if (subStrTem.substring(0, subStrLen).equals(subStrTem.substring(index - subStrLen + 1, index + 1))){
// break;
// }
// }
for(subStrLen = preIndexReStrLen +1; subStrLen > 0; subStrLen--){
if (subStrTem.substring(0, subStrLen).equals(subStrTem.substring(index - subStrLen + 1, index + 1))){
break;
}
}
return subStrLen;
}
/**
* 简化的三层循环
* @param str
* @return
*/
private String findLongestSubString(String str) {
int maxSubStrLen = 0;
int maxSubStrPos = 0;
/**
* 对str有效性做检验
*/
if(!checkValid(str)){
return null;
}
/**
* 双重遍历,寻找存在的重复子串，并记录重复子串长度：
* 外重循环：两个子串起始坐标的间隔,从（1，len(str)-1）
* 内重循环：从源串的起始位置，依次往后遍历
* 维护找到的最长重复子串的长度以及起始位置。
*/
int strLength = str.length();
for (int interval = 1; interval < strLength; interval++){
for (int pos = 0; pos + interval < strLength; pos++){
int subStrLen = 0;
try {
while (str.charAt(pos + subStrLen) == str.charAt(pos + interval + subStrLen)){
subStrLen++;
if (pos + interval + subStrLen >= strLength){
break;
}
}
} catch (Exception e) {
e.printStackTrace();
System.out.println("pos: "+pos+"; interval: "+interval);
}
if (subStrLen > maxSubStrLen){
maxSubStrLen = subStrLen;
maxSubStrPos = pos;
}
}
}
/**
* 构造子串，返回
*/
return str.substring(maxSubStrPos, maxSubStrPos+maxSubStrLen);
}
private boolean checkValid(String str) {
return StringUtils.isNotBlank(str);
}
/***
* 原始的三层循环
*/
private String findSubStr(String str){
/**
* 定义重复出现的最大子串
*/
String maxSubStr = "";
/**
* 定义内层循环找到重复子串的标记，默认false,为找到，内层循环一旦找到，就跳出外层循环
*/
boolean gotFlag = false;
/**
* 遍历所有可能的最大长度，理论最大值len(str)-1
*/
for (int subStrLen = str.length()-1; subStrLen > 0; subStrLen--){
/**
* 遍历str中所有长度为subStrLen的数组，验证是否重复
*/
for (int pos = 0; pos + subStrLen < str.length(); pos++){
/**
* 得到子串
*/
String subStr = str.substring(pos, pos+subStrLen);
/**
* 得到str首次出现子串的起始坐标
*/
int pos_fix = str.indexOf(subStr);
/**
* 得到str末次出现子串的起始坐标
*/
int pos_post = str.lastIndexOf(subStr);
/**
* 两者不相等则说明重复出现
*/
if (pos_fix != pos_post){
maxSubStr = subStr;
gotFlag = true;
break;
}
}
if (gotFlag == true){
break;
}
}
return maxSubStr;
}
}