字符串匹配算法
for (i = n - 1; i >= 0; i--)
//计算 rank 值，可能有多个字符串 rank 值相同 for (t = x, x = y, y = t, p = 1, x[sa[0]] = 0, i = 1; i < n; i++) x[sa[i]] = cmp(y, sa[i-1], sa[i], j) ? p - 1 : p++;
//查找主串 s 中模式串出现的次数 int match (char *s) { int cnt = 0; Node *p = root; for (int i = 0; s[i]; i++) { int id = s[i] - 'a'; while (!p->nxt[id] && p!=root) Node *tem = p; while (tem != root) cnt += tem->cnt, tem->cnt = 0, tem = tem->fail; //统计后清零，避免重复 计数 } return cnt; } int main () { int tc; while (tc--) { init(); scanf("%d", &tc); p = p->fail; p = p->nxt[id] ? p->nxt[id] : root;
return -1; } =====================================================================
扩展 kmp 算法
//s 为文本串，t 为模式串 char s[MX], t[MX]; int nxt[MX], extend[MX]; void getExtendNext (const char *t, const int lt, int *nxt) { for (int i = 1, j = -1, a, p; i < lt; i++, j--) if (j < 0 || i + nxt[i - a] >= p) { if (j < 0) j = 0, p = i; while (p < lt && t[j] == t[p]) j++, p++; nxt[i] = j, a = i; } else } void getExtend (const char *s, const int ls, const char *t, const int lt, int *extend, int *nxt) { getExtendNext(t, lt, nxt); for (int i = 0, j = -1, a, p; i < ls; i++, j--) if (j < 0 || i + nxt[i - a] >= p) { if (j < 0) j = 0, p = i; j++, p++; while (p < ls && j < lt && s[p] == t[j]) extend[i] = j, a = i; } else } ===================================================================== extend[i] = nxt[i - a]; nxt[i] = nxt[i - a]; LCP（Longest Common Prefix） //nxt[i]：t 中以第 i 位开始的后缀与整串的 lcp，extend[i]:s 中第 i 位开始的后缀与 t 的 lcp
char word[55]; int n; scanf("%d", &n); //模式串的个数 while (n--) getFail(); scanf("%s", word), insert(word);
scanf("%s", txt); } }
//主串
printf("%d\n", match(txt));
int st = 0, ed = 1;
//出队
t++]; if(st == mx) st = 0;
for (int i = 0; i < 26; i++)
if (p->nxt[i]) { if (p == root) else { Node *q = p->fail; while (q) { if break; } else } if (!q) } Q[ed++] = p->nxt[i]; } } } if (ed == mx) ed = 0; //入队 p->nxt[i]->fail = root; q = q->fail; (q->nxt[i]) { p->nxt[i]->fail = q->nxt[i]; p->nxt[i]->fail = root;
Node *fail, *nxt[26];
char word[55], txt[mx]; //模式串、主串 //初始化 Trie 树根节点 void init () { root = node; } tot = 1; memset(root, 0, sizeof(Node));
//把模式 s 插入到 Trie 树 void insert (char *s) { Node *p = root; for(int i = 0; s[i]; i++) { int tem = s[i] - 'a'; if(!p->nxt[tem]) { p->nxt[tem] = node + tot++; memset(p->nxt[tem], 0, sizeof(Node)); } p = p->nxt[tem]; } p->cnt++; }
字符串算法总结：
=====================================================================
朴素字符串匹配
int match (char *s, char *t) { int ls = strlen(s), lt = strlen(t), ids = 0, idt = 0; while (ids<ls && idt<lt) { if (s[ids] == t[idt]) else } if (idt == lt) return ids - lt; return -1; } ===================================================================== { ids++, idt++; } ids -= idt - 1; idt = 0;
//生成失败指针 //过程：设当前节点字符为 X，沿着其父亲的失败指针走 // // 如果他的儿子中也有字符为 X 的节点 N,则将当前节点的失败指针指向 N 否则一直走到 root，把失败指针指向 root //循环队列
Node *Q[mx]; void getFail () { Q[0] = root; {
//对第一关键字进行排序 for (i = 0; i < n; i++) for (i = 0; i < m; i++) for (i = 0; i < n; i++) for (i = 1; i < m; i++) wv[i] = x[y[i]]; wn[i] = 0; wn[wv[i]]++; wn[i] += wn[i-1]; sa[--wn[wv[i]]] = y[i];
for (i = n - 1; i >= 0; i--)
//以倍增的方法对以每个字符串开始的长度为 2^(j+1)的子串进行排序 for (j = 1, p = 1; p < n; j *= 2, m = p) { //对第二关键字进行排序（利用前面 sa 的结果） for (p = 0, i = n - j; i < n; i++) for (i = 0; i < n; i++) y[p++] = i; y[p++] = sa[i] - j; if (sa[i] >= j)
=====================================================================
后缀数组（倍增算法）
#include <cstdio> #include <cstring>
//n 为不加 0 时的字符串长度 //r[i]为原始字符串(0-n，第 n 个为添加的 0) //sa[i]为排序后第 i 个后缀的起始位置(0-n) //rnk[i]为以 i 为起始位置的后缀排序后排第几(0-n_1) //height[i]为排第 i 和第 i-1 的后缀的最长公共前缀(1-n) const int mxsz = 250000; char str[mxsz]; int r[mxsz], sa[mxsz], rank[mxsz], height[mxsz]; int wa[mxsz], wb[mxsz], wv[mxsz], wn[mxsz]; int cmp (int *r, int a, int b, int l) { return r[a]==r[b] && r[a+l]==r[b+l]; } /** 后缀数组 倍增算法 (r 为待排序字符串(r[0]-r[n-1]，最大值为 m)，sa 为后缀数组，n 为包含末尾 0 时的总长度) 在使用倍增算法前，需要保证 r 数组的值均大于 0。 然后要在原字 符串后添加一个 0 号字符。 这时候，若原串的长度为 n，则实际要进行后缀数组构建的 r 数组的长度应该为 n+1. 所以调用 DA 函数时，对应的 n 应为 n+1.*/ void da(int *r, int *sa, int n, int m) { int i, j, p, *x = wa, *y = wb, *t;
字符串匹配度算法
字符串匹配度算法字符串匹配度算法是计算两个字符串之间相似程度的一种算法。
在信息检索、文本分类、推荐系统等领域广泛应用。
它通过计算字符串之间的相似度来判断它们之间的关系，从而方便我们进行各种文本处理和分析工作。
字符串匹配度算法的核心思想是将字符串转换为向量表示，然后通过比较向量之间的距离或相似度来衡量字符串之间的相似程度。
常用的字符串匹配度算法有编辑距离算法、余弦相似度算法、Jaccard相似度算法等。
编辑距离算法是最常见的字符串匹配度算法之一，它衡量两个字符串之间的差异程度。
编辑距离算法将两个字符串进行插入、删除和替换操作，使它们变得相同。
通过计算进行了多少次操作，就可以得到它们之间的编辑距离。
编辑距离越小，表示两个字符串越相似。
余弦相似度算法是一种常用的基于向量的字符串匹配度算法。
它将字符串转换为向量表示，然后计算它们之间的夹角余弦值。
夹角余弦值越接近于1，表示两个字符串越相似；越接近于0，表示两个字符串越不相似。
Jaccard相似度算法是一种用于计算集合之间相似度的算法，也可以用于衡量字符串之间的相似度。
Jaccard相似度算法将字符串看作是字符的集合，然后计算它们之间的共同元素比例。
共同元素比例越高，表示两个字符串越相似。
除了这些常用的字符串匹配度算法外，还有很多其他的算法可以用于字符串的相似性比较。
不同的算法适用于不同的场景和需求，我们可以根据具体情况选择合适的算法。
总的来说，字符串匹配度算法是一种十分重要的工具，它可以帮助我们理解和处理文本数据。
在实际应用中，我们可以根据具体的需求选择合适的算法，从而完成各种文本处理和分析任务。
通过深入研究和应用这些算法，我们可以提高信息检索的准确性，加快文本处理的速度，提升推荐系统的效果。
希望大家能够重视字符串匹配度算法的研究和应用，为解决实际问题做出更多贡献。
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算法。
【字符串匹配】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}的后缀有部分重合的时候，并且重回部分相等的时候，就可能会存在完全匹配的情况。
所以针对这种情况我们不仅要看好后缀在模式串中，是否有另⼀个匹配的字串，我们还要考察好后缀的后缀字串是否存在跟模式串的前缀字串匹配的情况。
如下图所⽰：最后总结如何确定模式串向后滑动的位数，我们可以分别计算好后缀和坏字符往后滑动的位数，然后取两个数中最⼤的。
字符串匹配问题的算法步骤
字符串匹配问题的算法步骤字符串匹配是计算机科学中常见的问题，主要用于确定一个字符串是否包含另一个字符串。
解决这个问题的算法可以分为暴力匹配算法、Knuth-Morris-Pratt（KMP）算法和Boyer-Moore(BM)算法等。
暴力匹配算法是最简单的一种方法。
它的基本思想是从主串的第一个字符开始，依次和模式串的每个字符进行比较，直到找到一个字符不匹配为止。
如果找到了不匹配的字符，则将主串的指针后移一位，重新开始匹配。
如果匹配成功，模式串的指针向后移一位，主串的指针也向后移一位，继续匹配。
这个过程一直进行下去，直到模式串的指针到达模式串的末尾，或者找到了一个匹配的子串。
尽管暴力匹配算法很简单，但是它的时间复杂度较高，为O(m*n)，其中m是主串的长度，n是模式串的长度。
当主串和模式串很长时，暴力匹配算法的效率就会很低。
为了提高字符串匹配的效率，有很多其他的算法被提出。
其中比较著名的是KMP算法和BM算法。
KMP算法的核心思想是，当发生不匹配的情况时，不需要回溯主串的指针，而是通过已经匹配的部分字符的信息，将模式串的指针移动到一个新的位置，从而避免了不必要的比较。
具体来说，KMP算法在匹配的过程中，通过建立一个部分匹配表（Partial Match Table），来记录模式串中每个位置的最长前缀后缀的长度。
当发生不匹配的情况时，根据部分匹配表的信息，可以将模式串的指针直接移动到下一个可能匹配的位置。
BM算法是一种基于启发式的匹配算法，它的核心思想是从模式串的尾部开始匹配，并根据已经匹配的部分字符的信息，跳跃式地移动模式串的指针。
具体来说，BM算法分别构建了坏字符规则和好后缀规则。
坏字符规则用于处理主串中与模式串不匹配的字符，找到最右边的该字符在模式串中的位置，并移动模式串的指针到对齐该字符。
好后缀规则用于处理主串中与模式串匹配的部分，找到最右边的该部分在模式串中的位置，并移动模式串的指针到对齐该部分。
字符串模式匹配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算法等，可以根据具体应用场景选择合适的算法。
字符串模式匹配算法系列（一）：BF算法
字符串模式匹配算法系列（⼀）：BF算法算法背景：BF（Brute Force）算法，是⼀种在字符串匹配的算法中，⽐较符合⼈类⾃然思维⽅式的⽅法，即对源字符串和⽬标字符串逐个字符地进⾏⽐较，直到在源字符串中找到完全与⽬标字符串匹配的⼦字符串，或者遍历到最后发现找不到能匹配的⼦字符串。
算法思路很简单，但也很暴⼒。
算法原理：假设源字符串为“⾮常地⾮常地⾮常地喜欢你”，我们想从中寻找⽬标字符串“⾮常地⾮常地喜欢”，则BF算法的过程可以表述如下：第1轮：将源字符串和⽬标字符串对齐，并下标0开始逐个向后⽐较每个字符。
结果发现双⽅的第1个字符都是“⾮”、第2个字符都是“常”、……，但到了第7个字符时发现不⼀致：源字符串为“⾮”、⽬标字符串为“喜”，因此这⼀轮匹配不成功。
第2轮：将⽬标字符串整体向后移动1个字符的位置（即将⽬标字符串的第1个字符与源字符串的第2个字符对齐），并开始逐个向后⽐较每个字符，结果发现两个字符串的第1个字符就不⼀致，因此这⼀轮匹配也不成功。
第3轮：类似地，将⽬标字符串整体向后移动1个字符的位置（即将⽬标字符串的第1个字符与源字符串的第3个字符对齐），并开始逐个向后⽐较，结果发现两个字符串的第1个字符就不⼀致，因此这⼀轮匹配也不成功。
第4轮：这⼀轮终于发现，⽬标字符串的每个字符都能和源字符串对应起来，匹配成功！因此算法结束并根据需要返回相应的信息（⽐如返回这⼀轮源字符串遍历起始点的位置下标3）算法实现：BF算法的python实现如下：1#!/usr/bin/env python2#-*- coding: utf-8 -*-3import sys4import pdb56 reload(sys)7 sys.setdefaultencoding('utf-8')8910class BruteForce(object):11"""BF算法12成员变量:13 str_s: 源字符串14 str_t: ⽬标字符串15"""16def__init__(self, str_s, str_t):17 self.str_s = str_s18 self.str_t = str_t1920def run(self):21"""完全匹配则返回源字符串匹配成功的起始点的下标，否则返回-122"""23 base = 0 # 记录源字符串与⽬标字符串对齐的基准点24 len_s = len(self.str_s)25 len_t = len(self.str_t)2627while base + len_t <= len_s:28 step = 029while step < len_t:30if str_t[step] == self.str_s[base + step]:31# 当前字符相同，则继续⽐较下⼀个字符32 step += 133continue34# 当前字符不相同，则结束次轮⽐较，更新base基准位置，启动下⼀轮⽐较35 base += 136break37# 完全匹配成功，算法结论，返回匹配成功的基准点位置下标38if step == len_t:39return base40# 遍历了所有情况，最终匹配失败，返回-141return -1424344if__name__ == '__main__':45 str_s = u"⾮常地⾮常地⾮常地喜欢你"46 str_t = u"⾮常地⾮常地喜欢"47 model = BruteForce(str_s, str_t)48print model.run()复杂度分析：时间复杂度：假设源字符串长度为m，⽬标字符串长度为n，则：最好情况下是第⼀轮就成功匹配，则时间复杂度为O(n)；最坏情况下是遍历到最后才成功匹配，或者遍历到最后发现匹配不成功，则时间复杂度为O(n*(m-n+1))，⼀般实际使⽤时m >> n，所以可以认为趋近于O(m*n)；空间复杂度：由于不需要额外的存储空间，所以空间复杂度为O(1)算法评估：整个算法其实就循环执⾏如下两个步骤：⼀、从每⼀轮的基准点开始⽐较两个字符串；⼆、如发现不能完全匹配⽬标字符串，将⽬标字符串向后挪动⼀个字符的位置（即更新基准点）；如果想优化算法性能，那就简单分析⼀下：步骤⼀基本没有优化的空间：两个字符串⽐较就是需要从前向后逐个字符看是否匹配；步骤⼆可能有优化的空间：每轮发现不匹配时，⽬标字符串只能向后挪动⼀个字符的距离，所以会想到能否多往后挪动⼏个字符的距离？这样不就减少了步骤⼀⽐较的轮次数，从⽽加快速度了吗？这基本就是KMP算法的思路，下⼀篇会详细介绍。
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算法和Boyer-Moore算法。
1. 暴力匹配算法暴力匹配算法，也称为朴素匹配算法，是最简单的字符串匹配算法之一。
它的思想是从主串的第一个字符开始，逐个与子串进行比较，直到找到匹配或者遍历完整个主串。
具体实现时，可以使用两个指针分别指向主串和子串的第一个字符，然后循环比较两个指针所指向的字符。
如果字符相等，则继续比较下一个字符；如果字符不相等，则移动主串的指针到下一个位置，再重新开始比较。
暴力匹配算法的时间复杂度为O(mn)，其中m为主串长度，n为子串长度。
由于需要逐个比较字符，效率较低，尤其在处理大规模文本时。
2. KMP算法KMP算法（Knuth-Morris-Pratt算法）是一种高效的字符串匹配算法，可以在O(m+n)的时间复杂度内完成匹配。
该算法利用了子串内部的特点，避免了不必要的字符比较。
KMP算法的核心思想是构建一个部分匹配表，用于记录子串中每个位置的最长可匹配前缀和后缀的长度。
构建部分匹配表的过程可以在预处理阶段完成，时间复杂度为O(n)。
具体实现时，通过匹配过程中的前后指针的移动，根据部分匹配表和主串的字符进行比较。
如果字符匹配，则同时向后移动两个指针；如果字符不匹配，则根据部分匹配表的信息，移动子串的指针到指定位置，继续进行匹配。
KMP算法的优势在于避免了不必要的比较操作，提高了匹配效率。
它在文本搜索、模式识别等领域得到广泛应用。
3. Boyer-Moore算法Boyer-Moore算法是一种基于字符比较和移动的字符串匹配算法，具有较高的效率。
该算法先从子串的末尾开始与主串进行比较，然后根据比较结果选择合适的移动策略。
Boyer-Moore算法结合了两种不同的启发式策略，分别是坏字符规则和好后缀规则。
字符串快速匹配算法
字符串快速匹配算法字符串快速匹配算法，指的是在一个文本串中查找一个模式串的过程。
在计算机科学中，字符串匹配是一种基本的问题，在许多应用中都有广泛的应用，比如：文本编辑器、数据压缩、网络安全等等。
传统的字符串匹配算法，如朴素匹配算法和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树、后缀树等等。
这些算法各有特点，适用于不同的场景和数据类型。
在实际应用中，我们需要根据具体的需求和数据特征，选择合适的算法来完成字符串匹配任务。
经典算法—BF算法（字符串匹配）
经典算法—BF算法（字符串匹配）
前⾔
字符串的匹配算法也是很经典的⼀个算法，在⾯试的时候常常会遇到，⽽BF算法是字符串模式匹配中的⼀个简单的算法
1，什么是BF算法
BF算法，即暴⼒(Brute Force)算法，是普通的模式匹配算法，思想简单，代码结构也简单
BF算法的思想就是将⽬标串S的第⼀个字符与模式串T的第⼀个字符进⾏匹配，若相等，则继续⽐较S的第⼆个字符和 T的第⼆个字符；若不相等，则⽐较S的第⼆个字符和T的第⼀个字符，依次⽐较下去，直到得出最后的匹配结果。
2，代码实现
分析：
要完成对于所有字符的匹配⼯作，可以遍历母串，并逐个与⼦串⽐较，若相同，则字串匹配位后移，若不成功，归零，当匹配成功长度等于字串长度，结束遍历，返回结果
代码：
void Get(string a,string b)
{
int i,j=0;
for(i=0;i<a.length();i++)
{
if(a[i]==b[j]) //若匹配成功，则字串匹配字符后移⼀位
j++;
else //若不成功，字串重新从第⼀个开始，母串回溯
{
i=i-j+1;
j=0;
}
if(j==b.length())
{
cout<<"Yes Ok";
return;
}
}
if(j!=b.length()) cout<<"Sorry"
}
3，算法的复杂度
若母串长度位m，字串长度位n，则：
最好情况平均时间复杂度位：O(m+n)
最坏情况平均时间复杂度位：O(m*n）。