用于在字符串中搜索子字符串的快速算法

Question

我想要一个高效的算法（或库），我可以在 Java 中使用它来搜索字符串中的子字符串。

我想做的是：

给定一个输入字符串 - INSTR：

“BCDEFGH”

还有一组候选字符串——CAND：

“AB”、“CDE”、“FG”、“H”、“IJ”

在 INSTR

中查找任何与子字符串匹配的 CAND 字符串

在本例中，我将匹配“CDE”、“FG”和“H”（但不匹配“AB”和“IJ”）

可能有数千个候选字符串（在 CAND 中），但更重要的是，我将进行数百万次此搜索，因此我需要它是 FAST。

我想使用 char 数组。此外，我对架构解决方案没有兴趣，例如分发搜索 - 只是在本地执行它的最有效的功能/算法。

此外，CAND 和 INSTR 中的所有字符串都相对较小（

---

更新我应该提到，CAND 字符串集在 INSTR 的所有值中是不变的。

更新我只需要知道有匹配 - 我不需要知道匹配是什么。

最终更新 由于实现简单，我选择尝试 AhoCorsick 和 Rabin-Karp。 因为我有可变长度的模式，所以我使用了一个修改过的 Rabin-Karp，它对每个模式的前 n 个字符进行哈希处理，其中 n 是最小模式的长度，N 是我的滚动子字符串搜索窗口的长度。 对于 Aho Corsick，我使用了 this

在我的测试中，我在两篇新闻报纸文章中搜索了 1000 种模式，平均经过 1000 次迭代等... 完成的标准化时间是：

AhoCorsick：1

拉宾卡普：1.8

朴素搜索（检查每个模式并使用 string.contains）：50

---

*描述以下答案中提到的算法的一些资源：

http://www.seas.gwu.edu/~simhaweb/cs151/lectures/module5/module5.html

http://www.cs.princeton.edu/courses/archive/spr09/cos226/lectures/18SubstringSearch-2x2.pdf

http://www-igm.univ-mlv.fr/~lecroq/string/index.html*

Answer 1

阅读Aho-Corasick algorithm 和Rabin-Karp algorithm。

如果输入不是太大，您不想重复搜索很多次并且您没有很多模式，那么多次使用单个模式算法可能是个好主意。 Wikipedia article on search algorithms 提供了许多具有运行和预处理时间的算法。

实现：

• https://hkn.eecs.berkeley.edu/~dyoo/java/index.html
• http://algs4.cs.princeton.edu/53substring/RabinKarp.java.html
• https://github.com/hankcs/AhoCorasickDoubleArrayTrie
• https://github.com/RokLenarcic/AhoCorasick
• https://github.com/robert-bor/aho-corasick

演示文稿：

• http://www.slideshare.net/taka111/ahocorasick-string-matching-algorithm-15078438

Answer 2

将候选字符串集合转换为确定性有限状态自动机，然后在线性时间内遍历输入字符串。标准书籍中详细介绍了将单个字符串转换为 DFS 的内容。您可以通过首先构造一个非确定性自动机然后确定它来转换一组字符串。在最坏的情况下，这可能会在自动机大小的情况下造成指数爆炸，但之后的搜索速度很快；特别是如果目标字符串很长而候选字符串很短，这会很好地工作。

Answer 3

这就是正则表达式的用途。如上所述，您需要有限状态自动机，但这正是标准正则表达式匹配器的实现方式。

在java中你可以这样写：

StringBuilder sb = new StringBuilder();
bool first = true;
for (String subStr : substrings) {
    if (first)
        first = false;
    else
        sb.append('|');
    sb.append(escape(subStr));
}
Pattern p = Pattern.compile(sb.toString());

escape 方法应该转义任何在正则表达式中具有特殊含义的字符。

Answer 4

Rabin-Karp multiple pattern search 似乎是最快的。

Answer 5

您可能想研究Aho-Corasick algorithm 和相关算法。我不知道有什么库可以临时实现这个，但这是解决这个问题的经典方法。

Answer 6

还要检查Boyer-Moore algorithm 是否有单字符串模式匹配。

Answer 7

我们可以利用字符串的小尺寸（

我们可以在一次哈希中哈希所有可能的 INSTR 子字符串，这将花费 O(n^2) 时间。然后不管 CAND 字符串的数量，查找将是 O(1)。值得为大量的 CAND 字符串。

如果 INSTR 很大，那么我们可以构建一个后缀数组而不对其进行排序，这样顶部的项是最长的 (=N)，底部的项是 INSTR 的最后一个字符。现在对于每个 CAND 字符串，只要 length(CAND)

Answer 8

另一种解决方案是为 INSTR 使用suffix array。
由于 INSTR 很小，您可以使用冒泡排序对其进行排序。

之后您可以在 O(logN) 时间内搜索特定的 CAND 字符串，
其中 N = 长度（后缀数组）= 长度（INSTR）。

Answer 9

Here 是 Java 中快速字符串搜索算法的一些实现。

Answer 10

import java.util.Scanner;

public class StringMatch 
{
    static int temp,i=0,j=0; static boolean flag=true,matcher=false;

    static String str=null,mstr=null;static char astr[],amstr[];

    static void getter(){
        Scanner sc = new Scanner(System.in);
        str = sc.nextLine();
        //String str="today is Monday"; 
        astr=str.toCharArray();
         mstr = sc.nextLine();
        //String mstr="is"; 
         amstr=mstr.toCharArray();
    }

    static void stringMatch(){
        while(i<astr.length){
            if(astr[i]==amstr[j]){
            while((j!=amstr.length)&&flag){temp=i;
                if(astr[i]!=amstr[j]) {flag=false;matcher=false;}
                else{matcher=true;}
                i++;j++;
                //System.out.println(i+"\t"+j);
            }if(matcher==true)break;i=temp;}i++;j=0;flag=true;

        }
        if(matcher==true) {System.out.println("true");}
        else    {System.out.println("false");}
    }

    public static void main(String[] args) {

    StringMatch.getter();
    StringMatch.stringMatch();

    }
}