快速字符串检查寻找字符串内重复

Question

string = "aabbccaaabbcbbdbabdaaa";
如何以有效的方式检查该字符串以查找内部字符串重复项：
我的意思是：

1. 在string中寻找2个字母的字符串：
   

   aa = " aa bbcc aa abbcbbdbabd aa a";
   //这里没有空格或string 中的其他地方。只是添加它们以强调“aa”。
   aa = "aa bbcca aa bbcbbdbabda aa ";
   总 aa = 5;
   aa 之间的距离 = 4,5,11,12;
   
   bb = "aa bb ccaaa bb c bb dbabdaaa";
   总计 bb = 3;
   bb 之间的距离 = 5,1
   ...
   
   

2. 在 string 中寻找 3 个字母的字符串：
   

   aaa = " aaa bbcc aaa bbcbbdbabd aaa ";
   总 aaa = 3;
   aaa 之间的距离 = 4,10;
   ...

我的尝试是以 4 个周期的方式进行的，而且非常慢。

附言
任何帮助表示赞赏。对不起我的英语不好。

编辑：
抱歉问了不好的问题。我忘了说 string 还应该检查 4 个字符重复和其他字符重复：
aabb = " aabb cca aabb cbbdbabdaaa";
总计 aabb = 2;
aabb 之间的距离 = 3；


编辑 2：
我们正在寻找的重复项不应手动输入。假设string 是 20k 个符号，您正在搜索 ANY 重复项（没有空格）以及这些重复项之间的距离。
再次感谢并为不正确的问题再次道歉。

Answer 1

这是 C# 中的解决方案

static Dictionary<string, List<int>> GetDuplicates2(string value)
{
    var duplicates = new Dictionary<string, List<int>>();
    for (int i = 0; i < value.Length; i++)
    {
        for (int slength = 2; slength < (value.Length - i) / 2 + 2; slength++)
        {
            var littleString = value.Substring(i, slength);

            if (!duplicates.ContainsKey(littleString))
            {
                int nextOccurrence = value.IndexOf(littleString, i + slength - 1);

                if (nextOccurrence != -1)
                {
                    var l = new List<int>();
                    l.Add(i);
                    l.Add(nextOccurrence);
                    duplicates.Add(littleString, l);

                    while ((nextOccurrence = value.IndexOf(littleString, nextOccurrence + slength - 1)) != -1)
                    {
                        duplicates[littleString].Add(nextOccurrence);
                    }
                }
                else
                {
                    break;
                }
            }
            else
            {
                break;
            }
        }
    }

    return duplicates;
}

我是根据你的评论写的……

所有 [2, 3, ..., n/2] 个重复字符的列表，其中 n = 字符串 长度

我认为这工作得很好。它返回一个包含字符串和每个重复项的索引的字典。在性能方面，多次调用IndexOf() 可能是其中最慢的部分，但我不知道有什么办法。

更新 我更改了代码以包含重叠要求。

更新 #2 我添加了几个条件，其中算法将break 退出内部for 循环。这大大提高了性能（尤其是在找不到重复项的情况下）。

Answer 2

有很多字符串搜索算法。

维基百科页面很好地总结了它们：

http://en.wikipedia.org/wiki/String_searching_algorithm

Answer 3

在 Javascript 中使用普通字符串函数。

var a = " aa bbcc aa abbcbbdbabd aa a";
var s = "aa", ix = [], i=0; 
while(true){
    i = a.indexOf(s, i);
    if(i==-1)
       break;
    i += s.length
    ix.push(i);
}

现在ix 包含找到s (=aa) 的索引数组。 ix.length 是发现的总数。而下面的算法会发现两者之间的差异。

var differences=[];
for(var j=1; j<ix.length; j++){
    differences.push(ix[j]-ix[j-1]);
} 

这比正则表达式更快。

Answer 4

这几乎与LZW compression algorithm 所做的完全一样，并且只需要通过字符串一次。

Answer 5

JavaScript。

    onclick = "f('a',3)"  //return 2
    onclick = "f('a',2)"  //return 5
    .......
    var f = function(ch, nb){  //ch - searching character. nb - number of repetitions
       var str = "aabbccaaabbcbbdbabdaaa";
       var strLen = str.length;
       var res = 0;
       for(var i = 0; i < strLen; ++i){
          if(str[i] == ch){
             for(var j = i; j < nb+i || j <strLen; ++j){
                 if(str[j] != ch){
                 break;
                 }
                 if(j+1 == nb+i){
                 res++;
                 }
             }
          }
      }
    return res;
};