字符串匹配算法总结
java字符串模糊匹配算法
java字符串模糊匹配算法Java字符串模糊匹配算法是指在字符串匹配时，允许一定程度的差异或误差，以便更好地匹配目标字符串。
这种算法在实际应用中非常常见，例如在搜索引擎中，用户输入的关键词可能存在拼写错误或者语法不规范，这时候就需要使用模糊匹配算法来提高搜索结果的准确性。
Java字符串模糊匹配算法的实现主要有以下几种方法：1. Levenshtein距离算法Levenshtein距离算法是一种常见的字符串相似度算法，它可以计算两个字符串之间的编辑距离，即将一个字符串转换成另一个字符串所需的最少编辑次数。
编辑操作包括插入、删除、替换三种操作。
通过计算两个字符串之间的编辑距离，可以判断它们的相似度。
2. Jaro-Winkler距离算法Jaro-Winkler距离算法是一种字符串相似度算法，它可以计算两个字符串之间的相似度得分。
该算法主要通过计算字符串之间的匹配度、前缀匹配度和字符串长度等因素来确定相似度得分。
3. 模式匹配算法模式匹配算法是一种常见的字符串匹配算法，它可以在目标字符串中查找指定的模式字符串，并返回匹配结果。
该算法主要包括暴力匹配算法、KMP算法、Boyer-Moore算法等多种实现方式。
4. 正则表达式匹配正则表达式是一种强大的字符串匹配工具，它可以通过一系列的特殊符号和规则来匹配目标字符串中的特定内容。
在Java中，可以使用java.util.regex包中的类来实现正则表达式匹配。
以上这些算法都可以用于Java字符串模糊匹配，具体选择哪种算法取决于实际需求和数据规模。
在实际应用中，我们可以根据不同的场景选择不同的算法来提高匹配效率和准确性。
总之，Java字符串模糊匹配算法是一种非常重要的算法，在实际应用中具有广泛的应用价值。
通过选择合适的算法和优化算法实现，可以提高字符串匹配的效率和准确性，从而更好地满足用户需求。
常见5种基本匹配算法
常见5种基本匹配算法在计算机科学中，匹配算法（Matching algorithms）是指用于确定一个集合中的元素是否与另一个集合中的元素相匹配的算法。
匹配算法可以应用于各种领域，如字符串匹配、模式匹配、图匹配等。
下面介绍五种常见的基本匹配算法。
1. 暴力匹配算法（Brute Force Matching Algorithm）：暴力匹配算法是最基本的匹配算法之一、它遍历待匹配字符串和目标字符串，逐个字符进行比较，直到找到匹配或者遍历完整个字符串。
该算法的时间复杂度为O(n*m)，其中n和m分别是待匹配字符串和目标字符串的长度。
2. KMP匹配算法（Knuth-Morris-Pratt Matching Algorithm）：KMP匹配算法是一种优化的字符串匹配算法。
它通过预处理待匹配字符串的信息，快速确定定位下一次比较的位置，减少了不必要的比较次数，从而提高了匹配效率。
该算法的时间复杂度为O(n+m)，其中n和m分别是待匹配字符串和目标字符串的长度。
3. Boyer-Moore匹配算法：Boyer-Moore匹配算法是一种高效的字符串匹配算法。
它利用了字符出现位置的规律，从目标字符串的末尾开始匹配，并利用预处理的跳转表格快速跳过不匹配的字符，从而减少比较次数。
该算法的平均时间复杂度为O(n/m)，其中n和m分别是待匹配字符串和目标字符串的长度。
4. Aho-Corasick算法：Aho-Corasick算法是一种多模式匹配算法，适用于在一个文本中同时查找多个模式串的情况。
该算法利用Trie树的特性，同时利用一个自动机状态转移表格进行模式匹配，可以高效地找到多个模式串在文本中的出现位置。
该算法的时间复杂度为O(n+k+m)，其中n是文本长度，k是模式串的平均长度，m是模式串的个数。
5. Rabin-Karp算法：Rabin-Karp算法是一种基于哈希函数的字符串匹配算法。
它通过对待匹配字符串和目标字符串的部分子串进行哈希计算，比较哈希值是否相等，进而确定是否匹配。
BM算法总结
BM算法（全称Boyer-Moore Algorithm）是一种精确字符串匹配算法（只是一个启发式的字符串搜索算法）。
BM算法不同于KMP算法，采用从右向左比较的方法，同时引入了两种启发式Jump规则，即Bad-Character和Good-Suffix，来决定模板向右移动的步长。
BM算法的基本流程:文本串T（待匹配的字符串，长度n），模式串为P（用于去匹配的字符串模板，长度设为m）。
首先将T与P进行左对齐，然后进行从右向左比较（此时不移动模板和文本的相对位置，仅仅比较对齐位置上面是否相同，方向是右向左）。
若是某趟比较不匹配时，BM算法就采用两条启发式规则，即前面提到的Bad-Character和Good-Suffix，来计算模式串P向右移动的步长，直到整个匹配过程的结束。
1）Bad-characterBM 算法在上图中从右向左匹配中第一个字符就出现不一致的情况，此时需要采用两种情况来处理：a)如果T 中不匹配字符E 在模式P 中没有出现，那么我们很容易就能理解为E开始的m 长度的字符串不可能匹配到P（直观，无需解释），我们可以直接把P 跳过E，匹配后面的内容。
b)如果E 在模式P 中未进行匹配的字段中出现了，则以该字符E 进行对齐。
BM算法实现2）Good Suffix若发现某个字符不匹配的同时，已有部分字符匹配成功，则按如下两种情况进行:a)如果在P中位置t处已经匹配部分P’在P中某位置t’也出现，且位置t’的前一个字符与位置t的前一个字符不相同，则将P右移使t’对应t所在的位置。
b)如果P中任何位置已经匹配部分P’没有再出现，则找到与P’的后缀P’’相同的P的最长前缀x，向右移动P，使x对应刚才P’’后缀所在位置下面两个链接解释的很好：/sealyao/archive/2009/09/18/4568167.aspxhttp://www-igm.univ-mlv.fr/~lecroq/string/node14.html#SECTION00140void preBmBc(char *x, int m, int bmBc[]) //坏字符表预处理,x就是上文中的模式串P {int i; //注意：bmBc数组的下标是字符，而不是数字for (i = 0; i < ASIZE; ++i) //初始将所有ASIZE＝256个字符都赋初值为模式串的长度m，bmBc[i] = m; //也就是说模式串中没出现的字符，相应的移动距离都为m for (i = 0; i < m - 1; ++i)bmBc[x[i]] = m - i - 1;}Suffixes[]数组的计算方法。
字符串匹配度算法
字符串匹配度算法字符串匹配度算法是计算两个字符串之间相似程度的一种算法。
在信息检索、文本分类、推荐系统等领域广泛应用。
它通过计算字符串之间的相似度来判断它们之间的关系，从而方便我们进行各种文本处理和分析工作。
字符串匹配度算法的核心思想是将字符串转换为向量表示，然后通过比较向量之间的距离或相似度来衡量字符串之间的相似程度。
常用的字符串匹配度算法有编辑距离算法、余弦相似度算法、Jaccard相似度算法等。
编辑距离算法是最常见的字符串匹配度算法之一，它衡量两个字符串之间的差异程度。
编辑距离算法将两个字符串进行插入、删除和替换操作，使它们变得相同。
通过计算进行了多少次操作，就可以得到它们之间的编辑距离。
编辑距离越小，表示两个字符串越相似。
余弦相似度算法是一种常用的基于向量的字符串匹配度算法。
它将字符串转换为向量表示，然后计算它们之间的夹角余弦值。
夹角余弦值越接近于1，表示两个字符串越相似；越接近于0，表示两个字符串越不相似。
Jaccard相似度算法是一种用于计算集合之间相似度的算法，也可以用于衡量字符串之间的相似度。
Jaccard相似度算法将字符串看作是字符的集合，然后计算它们之间的共同元素比例。
共同元素比例越高，表示两个字符串越相似。
除了这些常用的字符串匹配度算法外，还有很多其他的算法可以用于字符串的相似性比较。
不同的算法适用于不同的场景和需求，我们可以根据具体情况选择合适的算法。
总的来说，字符串匹配度算法是一种十分重要的工具，它可以帮助我们理解和处理文本数据。
在实际应用中，我们可以根据具体的需求选择合适的算法，从而完成各种文本处理和分析任务。
通过深入研究和应用这些算法，我们可以提高信息检索的准确性，加快文本处理的速度，提升推荐系统的效果。
希望大家能够重视字符串匹配度算法的研究和应用，为解决实际问题做出更多贡献。
孙子算法总结
孙子算法总结引言孙子算法，又称字符串匹配算法，是一种用来在一个文本字符串中查找一个较短的模式字符串出现的位置的算法。
孙子算法的核心思想是通过对模式字符串和文本字符串进行比较，找到匹配的位置。
本文将对孙子算法的原理、实现和应用进行总结和分析。
原理1.首先，在模式字符串和文本字符串中，从左到右扫描每个字符。
2.当找到模式字符串与文本字符串的第一个字符匹配时，进入匹配阶段。
3.在匹配阶段，比较模式字符串和文本字符串中对应位置的字符。
4.如果字符匹配，则继续比较下一个字符；如果字符不匹配，则返回到第一步，查找下一个可能的匹配位置。
5.当模式字符串完全匹配时，返回匹配位置的索引值。
实现下面是孙子算法的实现思路：def find_pattern(text, pattern):n = len(text)m = len(pattern)i =0j =0while i < n:if text[i] == pattern[j]:i +=1j +=1else:i = i - j +1j =0if j == m:return i - jreturn-1应用孙子算法在实际开发中有着广泛的应用，特别是在字符串匹配和文本搜索方面。
以下是一些使用孙子算法的应用场景：字符串匹配在一个长文本中查找某个特定的短字符串，例如在一个文章中统计某个关键词的出现次数。
通过使用孙子算法，可以快速找到匹配位置。
文件搜索在文件系统中查找指定的文件名或者文件内容。
孙子算法可以用于搜索文件系统中的文件名或者文件内容的匹配情况，帮助用户快速定位所寻找的文件。
DNA序列匹配在生物学研究中，常常需要在DNA序列中查找特定的基因序列。
孙子算法可以在DNA序列中高效地进行匹配，从而辅助生物学研究的进行。
总结孙子算法是一种高效的字符串匹配算法，能够在文本字符串中快速查找模式字符串的匹配位置。
通过对模式字符串和文本字符串的比较，孙子算法可以快速找到匹配的位置，并应用于各种实际场景中。
python字符串匹配算法
python字符串匹配算法一、引言在计算机科学中，字符串匹配是指在文本中查找特定模式的子串。
这种操作在很多实际应用中都非常重要，例如在文件搜索、数据过滤、自然语言处理等领域。
Python提供了一些内置函数和库，可以方便地进行字符串匹配。
二、基本算法1. 朴素字符串匹配算法（Naive String Matching）：这是一种简单的字符串匹配算法，通过遍历文本串，逐个字符地与模式串进行比较，以确定是否存在匹配。
2. 暴力匹配算法（Brute Force）：这是一种基于字符比较的字符串匹配算法，通过逐个字符地比较文本串和模式串，直到找到匹配或者遍历完整个文本串为止。
3. KMP算法（Knuth-Morris-Pratt Algorithm）：这是一种高效的字符串匹配算法，通过记忆已经比较过的字符，减少不必要的重复比较，从而提高匹配速度。
三、Python实现1. 朴素字符串匹配算法：在Python中，可以使用`str.find()`方法或`str.index()`方法来查找模式串在文本串中的位置。
示例如下：```pythontext = "Hello, world!"pattern = "world"index = text.find(pattern)if index != -1:print("Pattern found at index", index)else:print("Pattern not found")```2. 暴力匹配算法：在Python中，可以使用`re`模块来实现暴力匹配算法。
示例如下：```pythonimport retext = "Hello, world! This is a test."pattern = "world"matches = re.findall(pattern, text)if matches:print("Pattern found in text")else:print("Pattern not found in text")```3. KMP算法：在Python中，可以使用`re`模块中的`search()`方法来实现KMP算法。
串的模式匹配算法
串的模式匹配算法字符串模式匹配是计算机科学中一种常用的算法。
它是一种检索字符串中特定模式的技术，可以用来在字符串中查找相应的模式，进而完成相应的任务。
字符串模式匹配的基本思想是，用一个模式串pattern去匹配另一个主串text，如果在text中找到和pattern完全匹配的子串，则该子串就是pattern的匹配串。
字符串模式匹配的过程就是在text中搜索所有可能的子串，然后比较它们是否和pattern完全匹配。
字符串模式匹配的算法有很多，其中著名的有暴力匹配算法、KMP算法、BM算法和Sunday算法等。
暴力匹配算法是最简单也是最常用的字符串模式匹配算法，其思想是从主串的某一位置开始，依次比较pattern中每一个字符，如果某个字符不匹配，则从主串的下一位置重新开始匹配。
KMP算法（Knuth-Morris-Pratt算法）是一种更为高效的字符串模式匹配算法，它的特点是利用了已匹配过的字符的信息，使搜索更加有效。
它的实现思想是，在pattern中先建立一个next数组，next数组的值代表pattern中每个字符前面的字符串的最大公共前缀和最大公共后缀的长度，这样可以在主串和模式串匹配失败时，利用next数组跳转到更有可能匹配成功的位置继续搜索，从而提高字符串模式匹配的效率。
BM算法（Boyer-Moore算法）也是一种高效的字符串模式匹配算法，它的实现思想是利用主串中每个字符最后出现的位置信息，以及模式串中每个字符最右出现的位置信息来跳转搜索，从而减少不必要的比较次数，提高搜索效率。
Sunday算法是一种简单而高效的字符串模式匹配算法，它的实现思想是，在主串中搜索时，每次从pattern的最右边开始比较，如果不匹配，则根据主串中下一个字符在pattern中出现的位置，将pattern整体向右移动相应位数，继续比较，这样可以减少不必要的比较次数，提高算法的效率。
字符串模式匹配算法的应用非常广泛，它可以用来查找文本中的关键字，检查一个字符串是否以另一个字符串开头或结尾，查找文本中的模式，查找拼写错误，检查字符串中是否包含特定的字符等。
【字符串匹配】BM（Boyer-Moore）字符串匹配算法详解总结（附C++实现代码）
【字符串匹配】BM（Boyer-Moore）字符串匹配算法详解总结（附C++实现代码）BM算法思想的本质上就是在进⾏模式匹配的过程中，当模式串与主串的某个字符不匹配的时候，能够跳过⼀些肯定不会匹配的情况，将模式串往后多滑动⼏位。
BM算法寻找是否能多滑动⼏位的原则有两种，分别是坏字符规则和好后缀规则。
坏字符规则：我们从模式串的末尾往前倒着匹配，当我们发现某个字符⽆法匹配时，我们把这个⽆法匹配的字符叫做坏字符（主串中的字符）。
此时记录下坏字符在模式串中的位置si，然后拿坏字符在模式串中查找，如果模式串中并不存在这个字符，那么可以将模式串直接向后滑动m位，如果坏字符在模式串中存在，则记录下其位置xi，那么模式串向后移动的位数就是si-xi，（可以在确保si>xi，执⾏减法，不会出现向前移动的情况）。
如果坏字符在模式串中多次出现，那我们在计算xi的时候，选择最靠后的那个，这样不会因为让模式串滑动过多，导致本来可能匹配的情况被略过。
好后缀规则：在我们反向匹配模式串时，遇到不匹配时，记录下当前位置j位坏字符位置。
把已经匹配的字符串叫做好后缀，记作{u}。
我们拿它在模式串中查找，如果找到了另⼀个跟{u}相匹配的字串{u*}，那么我们就将模式串滑动到字串{u*}与主串{u}对齐的位置。
如下图所⽰：如果在模式串中找不到另⼀个等于{u}的⼦串，我们就直接将模式串滑动到主串中{u}的后⾯，因为之前的任何⼀次往后滑动，都没有匹配主串中{u}的情况。
但是这种滑动做法有点太过头了，可以看下⾯的例⼦，如果直接滑动到好后缀的后⾯，可能会错过模式串与主串可以匹配的情况。
如下图：当模式串滑动到前缀与主串中{u}的后缀有部分重合的时候，并且重回部分相等的时候，就可能会存在完全匹配的情况。
所以针对这种情况我们不仅要看好后缀在模式串中，是否有另⼀个匹配的字串，我们还要考察好后缀的后缀字串是否存在跟模式串的前缀字串匹配的情况。
如下图所⽰：最后总结如何确定模式串向后滑动的位数，我们可以分别计算好后缀和坏字符往后滑动的位数，然后取两个数中最⼤的。
字符串模式匹配bf算法
BF算法，也就是Brute Force算法，是一种基本的字符串模式匹配算法。
它通过遍历文本串，逐一比较字符来实现模式匹配。
以下是BF算法的800字说明：1. 算法原理BF算法的基本原理是在文本串中从左到右依次扫描，对于扫描到的每一个位置，将该位置的文本与模式串中的每个模式字符进行比较，以确定是否存在匹配。
如果找到了匹配，则算法结束；否则，继续扫描下一个位置。
2. 算法步骤（1）初始化两个指针，一个指向文本串的起始位置，另一个指向模式串的起始位置；（2）比较起始位置的字符是否匹配，如果不匹配则算法结束；（3）如果匹配，移动两个指针，分别到下一个位置继续比较；（4）重复步骤（2）和（3），直到文本串完全扫描完或者没有匹配到为止。
3. 算法时间复杂度BF算法的时间复杂度是O(n*m)，其中n是文本串的长度，m是模式串的长度。
这是因为每次比较都需要花费一定的时间，而整个过程需要比较n-m+1次。
4. 算法优缺点优点：简单易懂，实现起来相对容易。
缺点：时间复杂度较高，对于较长的文本串和模式串，效率较低。
此外，BF算法只能用于查找单一的模式，对于多个模式的查找需要使用其他算法。
5. 实际应用BF算法在实际应用中主要用于文本搜索、模式匹配等场景。
例如，在搜索引擎中，BF算法常被用于网页的关键词匹配和搜索结果排序。
此外，BF算法还可以用于病毒扫描、文件校验等领域。
总之，BF算法是一种基本的字符串模式匹配算法，适用于简单的文本搜索和模式匹配场景。
虽然其时间复杂度较高，但对于一些特定的应用场景，BF算法仍然是一种有效的方法。
当然，随着计算机技术的发展，还有很多高效的模式匹配算法被提出，如KMP算法、BM算法、Rabin-Karp算法等，可以根据具体应用场景选择合适的算法。
python 字符串最大匹配算法
python 字符串最大匹配算法Python 字符串最大匹配算法在文本处理和自然语言处理中，字符串匹配是一个重要的任务。
而字符串最大匹配算法（Maximum Matching Algorithm）是一种常用的中文分词算法，也是处理字符串匹配问题的一种常用方法。
本文将介绍Python中的字符串最大匹配算法的原理和实现，并通过示例代码展示其在文本处理中的应用。
一、算法原理字符串最大匹配算法是一种启发式算法，其基本思想是从左到右依次寻找匹配的最长词语。
具体步骤如下：1. 定义一个词典，包含所有可能的词语。
2. 从左到右遍历待分词的文本，每次取最长的词语进行匹配。
3. 如果找到匹配的词语，则将其作为一个词语，继续从剩余的文本中寻找下一个最长的词语。
4. 如果没有找到匹配的词语，则将当前字符作为一个单字词，继续从下一个字符开始寻找最长词语。
5. 重复步骤3和步骤4，直到遍历完整个文本。
二、算法实现在Python中，可以通过以下代码实现字符串最大匹配算法的功能：```pythondef maximum_matching(text, dictionary):result = []while text:max_len = min(len(text), max(len(word) for word in dictionary))word = text[:max_len]while word not in dictionary and len(word) > 1:word = word[:-1]result.append(word)text = text[len(word):]return resulttext = "我爱北京天安门"dictionary = ["我", "爱", "北京", "天安门"]result = maximum_matching(text, dictionary)print(result)```以上代码中，`text`为待分词的文本，`dictionary`为词典，`result`为最大匹配的结果。
字符串快速匹配算法
字符串快速匹配算法字符串快速匹配算法，指的是在一个文本串中查找一个模式串的过程。
在计算机科学中，字符串匹配是一种基本的问题，在许多应用中都有广泛的应用，比如：文本编辑器、数据压缩、网络安全等等。
传统的字符串匹配算法，如朴素匹配算法和KMP算法，虽然可行，但是时间复杂度较高，对于大规模数据匹配效率较低。
为了提高字符串匹配效率，人们提出了许多快速匹配算法，如BM算法、Sunday算法、AC自动机等等。
BM算法是一种基于后缀匹配思想的快速字符串匹配算法，它的核心思想是在匹配的过程中，根据模式串的后缀字符来确定跳过的字符数。
BM算法的时间复杂度为O(n/m)，其中n为文本串的长度，m为模式串的长度，因此它可以在较短的时间内完成匹配任务。
BM算法的实现过程较为复杂，但是由于其高效性，被广泛应用于实际工程中。
Sunday算法是一种基于贪心思想的快速字符串匹配算法，它的核心思想是在匹配的过程中，每次从模式串的末尾开始比较，如果匹配成功，则直接返回匹配位置，否则通过预处理模式串中的字符来确定跳过的字符数。
Sunday算法的时间复杂度为O(n/m)，其中n 为文本串的长度，m为模式串的长度，因此它也可以在较短的时间内完成匹配任务。
Sunday算法的实现过程相对简单，适用于短模式串和长文本串的匹配。
AC自动机是一种基于字典树的快速字符串匹配算法，它的核心思想是将所有模式串构建成一个AC自动机，然后在文本串中进行匹配。
AC自动机的时间复杂度为O(n+k)，其中n为文本串的长度，k为模式串的总长度，因此它可以在非常短的时间内完成匹配任务。
AC 自动机的实现过程比较复杂，但是由于其高效性，被广泛应用于网络安全和搜索引擎等领域。
除了上述几种算法，还有许多其他的快速字符串匹配算法，如RK 算法、Trie树、后缀树等等。
这些算法各有特点，适用于不同的场景和数据类型。
在实际应用中，我们需要根据具体的需求和数据特征，选择合适的算法来完成字符串匹配任务。
字符串匹配kmp算法
字符串匹配kmp算法字符串匹配是计算机科学中的一个基本问题，它涉及在一个文本串中寻找一个模式串的出现位置。
其中，KMP算法是一种更加高效的算法，它不需要回溯匹配过的字符，在匹配失败的时候，根据已经匹配的字符和模式串前缀的匹配关系直接跳跃到下一次匹配的起点。
下面，我将详细介绍KMP算法原理及其实现。
1. KMP算法原理KMP算法的核心思想是：当模式串中的某个字符与文本串中的某个字符不相同时，根据已经匹配的字符和模式串前缀的匹配关系，跳过已经比较过的字符，从未匹配的字符开始重新匹配。
这个过程可以通过计算模式串的前缀函数（即next数组）来实现。
具体地，假设现在文本串为T，模式串为P，它们的长度分别为n和m。
当对于文本串T的第i个字符和模式串P的第j个字符（i和j都是从0开始计数的）进行匹配时：如果T[i]和P[j]相同，则i和j都加1，继续比较下一个字符；如果T[i]和P[j]不同，则j回溯到next[j]（next[j]是P[0]到P[j-1]的一个子串中的最长的既是自身的前缀又是后缀的子串的长度），而i不会回溯，继续和P[next[j]]比较。
如果匹配成功，则返回i-j作为P在T中的起始位置；如果匹配失败，则继续执行上述过程，直到文本串T被遍历完或匹配成功为止。
2. KMP算法步骤（1）计算模式串的前缀函数next[j]。
next[j]表示P[0]到P[j-1]的一个子串中的最长的既是自身的前缀又是后缀的子串的长度。
具体计算方式如下：先令next[0]=-1，k=-1（其中k表示相等前缀的长度，初始化为-1），j=0。
从j=1向后遍历整个模式串P：如果k=-1或者P[j]=P[k]，则next[j+1]=k+1，k=j，j+1；否则，令k=next[k]，再次执行步骤2。
（2）使用next数组进行匹配。
从文本串T的第0个字符开始，从模式串P的第0个字符开始匹配，如果匹配失败，根据next数组进行回溯。
字符串匹配方法
字符串匹配方法引言：字符串匹配是计算机科学中一项重要的技术，它在文本处理、数据分析、搜索引擎等领域都有广泛的应用。
本文将介绍几种常见的字符串匹配方法，包括暴力匹配、KMP算法、Boyer-Moore算法和正则表达式。
一、暴力匹配算法暴力匹配算法，也称为朴素匹配算法，是最简单直观的字符串匹配方法。
它的思想是从待匹配文本的第一个字符开始，依次与模式串进行比较，若匹配失败则移动到下一个字符继续比较，直到找到匹配的子串或者遍历完整个文本。
该算法的时间复杂度为O(n*m)，其中n为文本长度，m为模式串长度。
二、KMP算法KMP算法是一种高效的字符串匹配算法，它的核心思想是通过预处理模式串，构建一个部分匹配表（Next数组），以便在匹配过程中根据已匹配的前缀字符来确定下一次匹配的位置。
这样可以避免不必要的回溯，提高匹配效率。
KMP算法的时间复杂度为O(n+m)，其中n为文本长度，m为模式串长度。
三、Boyer-Moore算法Boyer-Moore算法是一种基于比较字符的右移策略的字符串匹配算法。
它的主要思想是从模式串的末尾开始与待匹配文本比较，若匹配失败则根据预先计算好的字符移动表来决定模式串的右移位数。
这样可以根据比较结果快速确定下一次比较的位置，从而提高匹配效率。
Boyer-Moore算法的时间复杂度为O(n/m)，其中n为文本长度，m为模式串长度。
四、正则表达式正则表达式是一种强大的字符串匹配工具，它通过一种特定的语法规则来描述字符串的模式，并通过匹配模式来判断字符串是否符合要求。
正则表达式可以实现复杂的匹配功能，包括字符匹配、重复匹配、分组匹配等。
在文本处理、数据清洗、搜索引擎等领域都有广泛的应用。
结论：字符串匹配是计算机科学中一项重要的技术，不同的匹配方法适用于不同的应用场景。
暴力匹配算法简单直观，适用于模式串较短的情况；KMP算法通过预处理模式串，提高匹配效率；Boyer-Moore算法通过右移策略，减少不必要的比较次数；正则表达式可以实现复杂的匹配功能。
字符串匹配算法
字符串匹配算法
字符串匹配算法是指在一个文本串S中查找一个模式串P的算法。
它的目的是在S中找出所有和P匹配的子串。
常用的字符串匹配算法有暴力匹配算法、KMP算法、BM算法和Sunday算法等。
1. 暴力匹配算法：
暴力匹配算法也叫朴素匹配算法，它是一种最简单的字符串匹配算法，它的基本思想是：从文本串S的左端开始，一个一个字符地与模式串P进行比较，直到文本串S中出现和模式串P完全匹配的子串为止。
2. KMP算法：
KMP算法是由Donald Knuth、Vaughan Pratt和James H.
Morris三人于1977年提出的一种改进的字符串匹配算法，它利用匹配失败后的信息，尽量减少模式串与主串的匹配次数以达到快速匹配的目的。
3. BM算法：
BM算法是由Boyer和Moore于1977年提出的一种改进的字符串匹配算法，它的基本思想是：利用匹配失败后的信息，从匹配失败的位置开始逆向查找，尽量减少模式串与主串的匹配次数以达到快速匹配的目的。
4. Sunday算法：
Sunday算法是由Udi Manber和Sun
Wu于1992年提出的一种改进的字符串匹配算法，它的基本思想是：利用匹配失败后的信息，从匹配失败的位置开始查找，尽量减少模式串与主串的匹配次数以达到快速匹配的目的。
C语言中的字符串匹配算法实现
C语言中的字符串匹配算法实现在C语言中，字符串匹配算法用于判断一个字符串是否包含另一个字符串。
本文将介绍几种常见的字符串匹配算法及其实现。
一、暴力匹配算法（Brute-Force Algorithm）暴力匹配算法是最简单直观的字符串匹配算法，也被称为朴素字符串匹配算法。
算法思想：从主字符串的第一个字符开始，依次与模式字符串的字符逐个比较，如果出现字符不匹配的情况，则主字符串的指针后移一位，再从下一个字符开始重新比较。
实现代码示例：```c#include <stdio.h>#include <string.h>int bruteForceMatch(char *str, char *pattern) {int len1 = strlen(str);int len2 = strlen(pattern);int i = 0, j = 0;while(i < len1 && j < len2) {if(str[i] == pattern[j]) {i++;j++;} else {i = i - j + 1;j = 0;}}if(j == len2) {return i - len2; // 返回匹配位置的索引} else {return -1; // 未找到匹配}}int main() {char str[] = "Hello, world!";char pattern[] = "world";int index = bruteForceMatch(str, pattern);if(index >= 0) {printf("匹配成功，匹配位置为：%d\n", index);} else {printf("未找到匹配\n");}return 0;}```上述示例代码中，我们使用了一个bruteForceMatch函数来实现暴力匹配算法。
BF算法KMP算法BM算法
BF算法KMP算法BM算法1. BF算法（Brute Force Algorithm）BF算法也称为暴力匹配算法，它是一种最简单直观的字符串匹配算法。
其原理是从目标字符串的第一个字符开始，逐个与模式字符串的字符进行比较，如果匹配失败，则将目标字符串的指针向后移动一位，再继续比较。
直到找到匹配或目标字符串被遍历完。
BF算法的时间复杂度为O(n*m)，其中n为目标字符串的长度，m为模式字符串的长度。
在最坏情况下，需要进行n-m+1次比较。
BF算法的优点是实现简单，适用于简单的字符串匹配问题。
但是对于大规模文本的匹配效率较低。
2. KMP算法（Knuth–Morris–Pratt Algorithm）KMP算法是一种改进的字符串匹配算法，通过利用已经匹配的信息来避免不必要的比较。
它首先构建一个部分匹配表（Partial Match Table），用于存储模式字符串每个前缀的最长公共前后缀的长度。
然后通过这个表来指导匹配过程。
KMP算法的核心思想是，当出现不匹配的字符时，通过部分匹配表中的信息，可以将模式字符串向后移动尽可能多的位置，而不是单纯地移动一位。
这样可以大大减少不必要的比较次数，提高匹配效率。
KMP算法的时间复杂度为O(n+m)，其中n为目标字符串的长度，m为模式字符串的长度。
在构建部分匹配表时需要O(m)的时间复杂度，匹配过程需要O(n)的时间复杂度。
KMP算法的优点是在大规模文本匹配时效率较高，缺点是算法较为复杂，需要额外的存储空间来存储部分匹配表。
3. BM算法（Boyer-Moore Algorithm）BM算法是一种高效的字符串匹配算法，通过利用不匹配字符的信息来跳过尽可能多的字符，从而减少比较次数。
其核心思想是从模式字符串的末尾开始匹配，并向前移动模式字符串。
BM算法分为坏字符规则和好后缀规则两部分：-坏字符规则：当遇到不匹配的字符时，将模式字符串根据目标字符串中的字符向后移动一位，从而跳过了部分字符的比较。
常用的匹配算法
71.
}
72.
else
73.
{
74.
i += delta_2[j];
75.
}
76.
j = find_len - 1;
77.
}
78.
if (j == -1)
79.
return i+1;
80. }
81.
82. return -1;
83. }
提示：该算法主要利用坏字符规则和好后缀规则进行转换。所谓坏字符规则，是指不能匹配时的字符在待匹配字串中从右边数的位置；而好 后缀规则则是指子串中从该不匹配位置后面所有字符（都是已匹配字符）再次在字串中出现的位置(k)，其中s[k,k+1,---,k+len-j-1] = s[j+1, j+1,---,len-1], 并且s[k-1] != [j] || s[k-1] = $, 其中$表示增补的字符，可以与任何字符相等。
30. int j = 0;
31. for (i=2; i<find_len; i++)
32. {
33.
while (1)
34.
{
35.
if (find[i-1] == find[j])
36.
{
37.
j++;
38.
if (find[i] == find[j])
39.
{
40.
map[i] = map[j];
//chars.
41.
for (k=1; j<(len-1) && k<len; k++)
42.
{
字符串精确匹配与比对
字符串精确匹配与比对一、概述字符串精确匹配与比对是计算机科学中的基本问题，即判断两个字符串是否完全相同或者其中一个字符串是否是另一个字符串的子串。
这个问题在各种文本处理和信息检索任务中都有广泛的应用，例如搜索引擎、文本分析和语言建模等。
二、字符串匹配算法字符串匹配算法中有许多不同的方法，包括暴力破解法、Knuth-Morris-Pratt算法、Boyer-Moore 算法、Rabin-Karp 算法等等。
1. 暴力破解法暴力破解法是最简单的字符串匹配算法。
它的基本思路是将模式串与文本串中的每一个子串按照相同的长度进行比对，直到找到匹配的子串或者整个文本串都被搜索完毕。
时间复杂度：O(m∗n)2. Knuth-Morris-Pratt 算法Knuth-Morris-Pratt 算法是一种基于有限状态自动机的字符串匹配算法，它的核心思想是利用已知的匹配信息避免重复比对。
具体地，算法维护一个状态转移表，记录当前匹配字符的状态，当匹配失败时，可以通过跳转转移表中的下一状态，避免重复比对已知的匹配信息。
时间复杂度：O(n+m)3. Boyer-Moore 算法Boyer-Moore 算法是一种基于启发式规则的字符串匹配算法，它的核心思想是从后往前匹配，利用不匹配字符带来的信息快速跳过一定数量的字符。
具体地，算法维护一个 Bad Character 规则和一个 Good Suffix 规则，分别记录当前字符不匹配情况下的下一次比对位置和最长相同后缀前缀长度，通过这些规则快速跳过不可能匹配的子串。
时间复杂度：O(n)4. Rabin-Karp 算法Rabin-Karp 算法是一种基于哈希函数的字符串匹配算法，它的核心思想是将字符串转化为数字计算哈希值进行匹配。
具体地，算法维护一个滑动窗口和一个哈希表，每次滑动窗口到下一个位置时，通过哈希表查询当前子串的哈希值是否与模式串相等，如果相等则可以判断为匹配。
时间复杂度：O(n+m)三、字符串比对应用场景字符串比对是一种基础性的技术，可以应用于许多不同的场景中。
KMP算法详解(超级详细)
KMP算法详解（超级详细）KMP算法，全称为Knuth-Morris-Pratt算法，是一种用于字符串匹配的快速算法。
它的核心思想是在匹配过程中，当出现不匹配的情况时，利用已经匹配的字符信息，避免进行重复匹配，从而提高匹配效率。
首先，我们需要了解一个重要的概念，"部分匹配值"（partialmatch table），它指的是字符串的前缀和后缀的最长的共有元素的长度。
例如，在字符串"ABCDABD"中，它的部分匹配值是[0, 0, 0, 0, 1, 2, 0]。
接下来，我们来详细了解KMP算法的实现过程：1.首先，针对模式串（被查找的字符串）进行预处理，得到部分匹配表。
-定义两个指针，i和j，分别指向模式串的开头和当前字符。
-初始化部分匹配表，将第一个元素置为0。
-在循环中，不断地根据当前指针所指向的字符，判断是否匹配。
-若匹配，则将部分匹配表的下一个元素置为当前指针位置的下一个元素的值加1，并同时将当前指针和i都自增1-若不匹配且i>0，则将i更新为部分匹配表的前一个元素的值。
-若不匹配且i=0，则将当前指针自增1-循环结束后，部分匹配表得到构建。
2.匹配过程：-定义两个指针，i和j，分别指向需要匹配的文本和模式串的开头。
-在循环中，不断地根据当前指针所指向的字符，判断是否匹配。
-若匹配，则将两个指针都自增1-若不匹配且j>0，则将j更新为部分匹配表的前一个元素的值。
-若不匹配且j=0，则将当前指针自增1-若模式串的指针j指向了最后一个字符，则说明匹配成功，返回匹配的位置。
-若循环结束仍未找到匹配的位置，则匹配失败。
总结一下，KMP算法可以分为两个步骤：预处理和匹配。
预处理的过程是构建部分匹配表，通过比较前缀和后缀的最长共有元素的长度，将这个长度记录在部分匹配表中。
匹配的过程是根据部分匹配表中的信息，来确定下一步的匹配位置，提高匹配的效率。
通过KMP算法，我们可以有效地解决字符串匹配问题，提高了匹配的效率。
字符串相似度匹配算法
字符串相似度匹配算法
字符串相似度匹配算法是指根据两个字符串之间的相似程度来判断它们是否匹配的一种算法。
这种算法主要应用于文本搜索、数据挖掘、自然语言处理、信息检索等领域。
常见的字符串相似度匹配算法包括：
1. 暴力匹配算法：也叫朴素算法，是最简单的字符串匹配算法之一。
它的思想是从文本串的第一个字符开始，逐个字符地与模式串进行比对，如果匹配失败，则通过移动文本串的指针来继续比对。
该算法的时间复杂度为O(m*n)，其中m是模式串的长度，n是文本串的长度。
2. KMP算法：是一种改进的字符串匹配算法，它利用已经匹配过的信息，尽可能减少了匹配的次数。
该算法的时间复杂度为O(m+n)，其中m是模式串的长度，n是文本串的长度。
3. BM算法：是一种基于坏字符规则和好后缀规则的字符串匹配算法。
它的思想是从模式串的末尾开始匹配，根据坏字符规则和好后缀规则来选择移动的距离，从而减少比对的次数。
该算法的时间复杂度为O(m*n)，但在实际应用中通常比KMP算法更快。
4. Levenshtein距离算法：是一种基于编辑距离的字符串匹配算法。
它的思想是通过计算两个字符串之间的编辑距离来判断它们的相似程度。
编辑距离是指将一个字符串转换成另一个字符串所需的最小编辑操作次数，包括插入、删除、替换三种操作。
该算法的时间复杂度为O(m*n)，其中m和n分别为两个字符串的长度。
总体而言，不同的字符串相似度匹配算法各有优缺点，需要根据具体的应用场景选择合适的算法。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
Brute Force(BF或蛮力搜索) 算法：这是世界上最简单的算法了。
首先将匹配串和模式串左对齐，然后从左向右一个一个进行比较，如果不成功则模式串向右移动一个单位。
速度最慢。
那么，怎么改进呢？我们注意到Brute Force 算法是每次移动一个单位，一个一个单位移动显然太慢，是不是可以找到一些办法，让每次能够让模式串多移动一些位置呢？当然是可以的。
我们也注意到，Brute Force 是很不intelligent 的，每次匹配不成功的时候，前面匹配成功的信息都被当作废物丢弃了，当然，就如现在的变废为宝一样，我们也同样可以将前面匹配成功的信息利用起来，极大地减少计算机的处理时间，节省成本。
^_^注意，蛮力搜索算法虽然速度慢，但其很通用，文章最后会有一些更多的关于蛮力搜索的信息。
KMP算法首先介绍的就是KMP 算法。
这个算法实在是太有名了，大学上的算法课程除了最笨的Brute Force 算法，然后就介绍了KMP 算法。
也难怪，呵呵。
谁让Knuth D.E. 这么world famous 呢，不仅拿了图灵奖，而且还写出了计算机界的Bible <The Art of Computer Programming>( 业内人士一般简称TAOCP). 稍稍提一下，有个叫H.A.Simon 的家伙，不仅拿了Turing Award ，顺手拿了个Nobel Economics Award ，做了AI 的爸爸，还是Chicago Univ 的Politics PhD ，可谓全才。
KMP 的思想是这样的：利用不匹配字符的前面那一段字符的最长前后缀来尽可能地跳过最大的距离比如模式串ababac 这个时候我们发现在c 处不匹配，然后我们看c 前面那串字符串的最大相等前后缀，然后再来移动下面的两个都是模式串，没有写出来匹配串原始位置ababa c移动之后aba bac因为后缀是已经匹配了的，而前缀和后缀是相等的，所以直接把前缀移动到原来后缀处，再从原来的c 处，也就是现在的第二个b 处进行比较。
这就是KMP 。
Horspool 算法。
当然，有市场就有竞争，字符串匹配这么大一个市场，不可能让BF 和KMP 全部占了，于是又出现了几个强劲的对手。
第一个登场的是Horspool 算法的思想很简单的。
不过有个创新之处就是模式串是从右向左进行比较的。
很好很强大，为后来的算法影响很大。
匹配串：abcbc sdxzcxx模式串：cbcac这个时候我们从右向左进行对暗号，c-c ，恩对上了，第二个b-a ，不对啊，我们应该怎么办？难道就这么放弃么。
于是，模式串从不匹配的那个字符开始从右向左寻找匹配串中不匹配的字符b 的位置，结果发现居然有，赶快对上赶快对上，别耽误了。
匹配串：abcbcsd xzcxx模式串：cbcac然后继续从最右边的字符从右向左进行比较。
这时候，我们发现了，d-c 不匹配啊，而且模式穿里面没有噢，没办法，只好移动一个模式串长度的单位了。
匹配串：abcbcsdxzcxx模式串：cbcacBoyer-Moore算法是一个很复杂的算法，当然，虽然理论上时间复杂度和KMP 差不多，但是实际上却比KMP 快数倍，可见实践是检验真理的唯一标准。
分为两步预处理，第一个是bad-character heuristics ，也就是当出现错误匹配的时候，移位，基本上就是做的Horspool 那一套。
第二个就是good-suffix heuristics ，当出现错误匹配的时候，我还要从不匹配点向左看啊，以前匹配的那段子字符串是不是在模式串本身中还有重复的啊，有重复的话，那么我就直接把重复的那段和匹配串中已经匹配的那一段对齐就是了。
再比较匹配串：abaccba bbazz模式串：cbadcba我们看到已经匹配好了cba ，但是c-d 不匹配，这个时候我们发现既可以采用bad-character heuristics ，也可以使用good-suffix heuristics( 模式串：cba dcba ) ，在这种情况下，邪不压正。
毅然投奔good 。
移动得到匹配串：abaccbabbaz z模式串：cbadcba可是，我们有时候也发现，已经匹配好的那一部分其实并没有再有重复了的啊。
这个时候，我们发现已经匹配好的那串字符串有一部分在开头重新出现了，那么，赶快，对齐吧。
匹配串：abacccb bbazz模式串：cbadccb然后得到匹配串：abacccbbbazz模式串：cbadccb当两种Good-Suffix 出现的时候，取移动距离最大的那个。
Sunday算法最后一个是Sunday 算法，实际上比Boyer-Moore 还快，呵呵。
长江后浪推前浪。
看原始论文的题目，D.M. Sunday 貌似是故意想气气Boyer-Moore 两位大牛似的。
呵呵。
不过实际上的确Sunday 算法的确比BM 算法要快，而且更简单。
Sunday 的算法思想和Horspool 有些相似，但是。
当出现不匹配的时候，却不是去找匹配串中不匹配的字符在模式串的位置，而是直接找最右边对齐的右一位的那个字符在模式串的位置。
比如：匹配串：abcbc zdxzc模式串：zbcac恩，这里我们看到b-a 没有对上，我们就看匹配串中的z 在模式串的位置，然后，嘿嘿。
匹配串：abcbczdxzc模式串：zbcac如果模式串中的没有那个字符怎么办呢？很简单，跳过去呗。
匹配串：abcbc edxzcs模式串：zbcace 不在模式串中出现那么我们就匹配串：abcbcedxzcs模式串：zbcac(2009/10/20补充)RK算法某一天在图书馆的一本算法分析设计书上翻到的。
思路很新颖！和大家分享下。
在串匹配的简单算法中，把文本每m个字符构成的字符段作为一个字段，和模式进行匹配检查。
如果能对一个长度为m的字符串赋以一个Hash函数。
那么显然只有那些与模式具有相同hash函数值的文本中的字符串才有可能与模式匹配，这是必要条件，而没有必要去考虑文本中所有长度为m的字段，因而大大提高了串匹配的速度。
因此RK 算法的思想和KMP，BM，Sunday等思路迥然不同！（事实上，之前的串匹配方法，是将模式串的一个一个字符作为小的特征去分别进行匹配，而RK算法则是将串整体作为一个特征！难就难在单个字符的特征很容易想得到，整体作为一个特征就没那么容易想得到了）如果把整体作为一个特征，那么如何快速的求出这个整体特征的特征值？？模式串的特征值仅需求一次即可。
对于文本中的任意m个字符构成的字串如何快速的求特征就是个难点了。
抛砖引玉，这里给出一个简单的特征计算。
将字符串的每一个字符看做一个数，那么这个字符串的就是一个数字数组，通过积分向量可以快速任意一个长度子字符串的向量和。
可以把字符串的对应的字符数组的元素和看做这个字符串整体特征。
这个特征是可以再O（1）的时间内求出的。
其实原始的RK算法里面是把字符串看做一个26进制数在计算特征的。
这里就不啰嗦了，有兴趣的可以深入查找aabsee sds 模式串eesees发现see向量和== ees的向量和然后就对see和ees做逐个字符的比较。
发现不匹配继续往下走aabsees ds 模式串eesees发现ees向量和== ees的向量和然后就对ees和ees做逐个字符的比较。
发现匹配OK。
另外还有字符串匹配自动机后缀树算法（分在线和非在线两种）等见如下文章。
不能说那个比那个更好，各个算法都有自己的优势及最佳应用场合。
参考：/yifan403/archive/2009/06/16/4272793.aspx另外，关于多模式字符串匹配有AC算法（字符串匹配自动机思想）WM算法（BM在多模式的推广应用）参考：/ijuliet/category/498465.aspx 该女子的blog有很多好文章。
/**********************华丽分割线******************************/附上sunday代码：/kmj0217/blog/item/6f837f2f3da097311e3089cb.html一种比KMP 和BM 更高效的匹配算法（如果想看原英文介绍，看下面分割线后的网址）适用于：模式串较短的情况，最坏时间复杂性为O(N*M)，不过一般没这么坏Sunday 算法其实思想跟BM算法很相似，只不过Sunday算法是从前往后匹配，在匹配失败时关注的是文本串中参加匹配的最末位字符的下一位字符。
如果该字符没有在匹配串中出现则直接跳过，即移动步长= 匹配串长度+ 1；否则，同BM算法一样其移动步长=匹配串中最右端的该字符到末尾的距离+1。
代码如下：/*Sunday-字符串匹配算法--一种优于KMP 的算法思想类似于BM 算法，只不过是从左向右匹配遇到不匹配的看大串中匹配范围之外的右侧第一个字符在小串中的最右位置另外：采用BM/KMP 的预处理的做法，事先计算好移动步长，等到遇到不匹配的值直接使用*/#include<iostream>#include<string.h>using namespace std;//一个字符8位最大256种#define MAX_CHAR_SIZE 256/*设定每个字符最右移动步长，保存每个字符的移动步长如果大串中匹配字符的右侧一个字符没在子串中，大串移动步长= 整个串的距离+1如果大串中匹配范围内的右侧一个字符在子串中，大串移动距离= 子串长度-这个字符在子串中的位置*/int *setCharStep(char *subStr){int *charStep=new int[MAX_CHAR_SIZE];int subStrLen=strlen(subStr);for(int i=0;i<MAX_CHAR_SIZE;i++)charStep[i]=subStrLen+1;//从左向右扫描一遍保存子串中每个字符所需移动步长for(int i=0;i<subStrLen;i++){charStep[(unsigned char)subStr[i] ]=subStrLen-i;}return charStep;}/*算法核心思想，从左向右匹配，遇到不匹配的看大串中匹配范围之外的右侧第一个字符在小串中的最右位置根据事先计算好的移动步长移动大串指针，直到匹配*/int sundaySearch(char *mainStr,char *subStr,int *charStep){int mainStrLen=strlen(mainStr);int subStrLen=strlen(subStr);int main_i=0;int sub_j=0;while(main_i<mainStrLen){//保存大串每次开始匹配的起始位置，便于移动指针int tem=main_i;while(sub_j<subStrLen){if(mainStr[main_i] == subStr[sub_j]){main_i++;sub_j++;continue;}else{//如果匹配范围外已经找不到右侧第一个字符，则匹配失败if(tem+subStrLen > mainStrLen)return -1;//否则移动步长重新匹配char firstRightChar=mainStr[tem+subStrLen];main_i =tem + charStep[(unsigned char)firstRightChar];sub_j=0;break;//退出本次失败匹配重新一轮匹配}}if(sub_j == subStrLen)return main_i-subStrLen;}return -1;}int main(){char *mainStr="absaddsasfasdfasdf";char *subStr="dd";int *charStep=setCharStep(subStr);cout<<"位置："<<sundaySearch(mainStr,subStr,charStep)<<endl;system("pause");return 0;}/*************************************************华丽的分割线***************************************/算法介绍以及实现伪码：http://www-igm.univ-mlv.fr/~lecroq/string/node19.htmlvoid preQsBc(char *x, int m, int qsBc[]) {int i;for (i = 0; i < ASIZE; ++i)qsBc[i] = m + 1;for (i = 0; i < m; ++i)qsBc[x[i]] = m - i;}void QS(char *x, int m, char *y, int n) {int j, qsBc[ASIZE];/* Preprocessing */preQsBc(x, m, qsBc);/* Searching */j = 0;while (j <= n - m) {if (memcmp(x, y + j, m) == 0)OUTPUT(j);j += qsBc[y[j + m]]; /* shift */}}// 第三个代码实现，貌似比较高效/azuryy/blog/item/10d3d3460b97af0e6b63e5cd.html头文件定义：/* Sunday.h */class Sunday{public:Sunday();~Sunday();public:int find(const char* pattern, const char* text);private:void preCompute(const char* pattern);private://Let's assume all characters are all ASCIIstatic const int ASSIZE = 128;int _td[ASSIZE] ;int _patLength;int _textLength;};源文件/* Sunday.cpp */Sunday::Sunday(){}Sunday::~Sunday(){}void Sunday::preCompute(const char* pattern){for(int i = 0; i < ASSIZE; i++ )_td[i] = _patLength + 1;const char* p;for ( p = pattern; *p; p++)_td[*p] = _patLength - (p - pattern);}int Sunday::find(const char* pattern, const char* text) {_patLength = strlen( pattern );_textLength = strlen( text );if ( _patLength <= 0 || _textLength <= 0)return -1;preCompute( pattern );const char *t, *p, *tx = text;while (tx + _patLength <= text + _textLength){for (p = pattern, t = tx; *p; ++p, ++t){if (*p != *t)break;}if (*p == 0)return tx-text;tx += _td[tx[_patLength]];}return -1;}简单测试下：int main(){char* text = "blog.csdn,";char* pattern = "csdn,blog" ;Sunday sunday;printf("The First Occurence at: %d/n",sunday.find(pattern,text));return 1;}////////////////////////////////////////////strstr的实现。