之前说到，朴素的匹配，每趟比较，都要回溯主串的指针，费事。则 KMP 就是对朴素匹配的一种改进。正好复习一下。
KMP 算法其改进思想在于：
每当一趟匹配过程中出现字符比较不相等时，不需要回溯主串的 i指针，而是利用已经得到的“部分匹配”的结果将模式子串向右“滑动”尽可能远的一段距离后，继续进行比较。如果 ok，那么主串的指示指针不回溯！算法的时间复杂度只和子串有关！很好。
KMP算法的关键是利用匹配失败后的信息，尽量减少模式串与主串的匹配次数以达到快速匹配的目的，很自然的，需要一个函数来存储匹配失败的信息。
先理解一个概念：前后缀字符串
比如"ababa"
前缀：a，ab，aba，abab，除了最后一个字符
后缀：a，ba，aba，baba，除了第一个 字符
比如"abcd"
前缀：a，ab，abc
后缀：d，cd，bcd
图解kmp 算法对朴素匹配改进的过程；
同样如图1，发生不匹配，朴素的做法是 j 到开头1出，i 到上次开始比较的位置的下一位2处（i回溯）
图1 
2
但是发现一个问题，那就是在 图1的3处，不匹配的时候，前面的字符已知是匹配的，ab 是模式串里临时匹配的串，如果 i 回溯，那么等于是白白去比较，因为要把"搜索位置"移到已经比较过的位置，重比一遍。无用功，如果此时 i 不动，直接就可以减少无用的比较次数（所谓无用是说以最少的比较次数，找出完全的匹配串，尽量少做不匹配比较，通过之前的信息来计算和判断），如上图2，i 不动，j 回溯到1，匹配，ij继续走……一直都是匹配的，直到图4
3 
4
那么不匹配了，临时的匹配串是 abca，如果 j 还是回到1，i 回溯到4（朴素的），我们发现1和4比较后不匹配，那么 i 继续右移，j 还是1，直到 i 到了6，才和 j=1处的 a 匹配，是不是之前的比较都是无用功？为什么不可以直接就和6比较呢？怎么解决呢？
发现一个规律：如果临时匹配串里，前后缀有重复，那么其实模式串的j，没必要每次都回到1，仔细思考是这样的。有一定规律可寻。
5 
6
整个过程结束，最后结果和朴素一样，但减少了比较次数，改进了时间复杂度，让 o（t） 只和模式串t有关，因为主串s是给定的，且 i 不回溯，一直往前走！
到这里，就要思考，如何找出 j 回溯的逻辑。
换一个角度思考；
之前我们的做法是都观察 i j 的回溯！如图，现在我们移动模式串来观察。
7 
8
图7不匹配， i 到2，j 到1，其实这相当于 T 右移，看图8。T 继续右移直到发生匹配，顺次比较，直到图9，红色标出，发现了不匹配，那么，按照之前的朴素做法，i 到4，j 还是1，相当于 T还是 右移一位！如下下图10。
9 
10
比较之后，不匹配，T 继续友谊，直到T 1处移动到S6处，才发生匹配，之后继续顺次比较，ok！找出了匹配串。
11
那么通过观察来思考：每当临时匹配串（已知的）前后有重复的时候，那么只需 把模式串 T 直接移动到后缀刚刚开始有重复的位置（设移动距离为 d），i 不回溯。也就是j 直接反向的回溯距离 d，亮着等价的。为什么这样？
因为，在字符串搜索和匹配的时候，经常有前后重复的时候，前缀和后缀重复！如倒数第3图的已知的临时匹配串abca，前后缀 a 重复！此时没必要再用模式串的首位a去和S 的 b 比较了，直接和前后缀子串第一次有重复的位置比较（设子串右移距离 d），也就是 a 处。如果还那么顺次比较，是做无用功！此时思考如何实现这个逻辑，找到对应的j 回溯的距离 d。这个距离 d 就是前后重复的字符串的距离。
设置一个数组next来返回模式串的 j 应该回溯的位置
若令数组next[j]=k，则next[j]表明当模式中第j个字符与主串中相应字符失配时，在模式中需要重新和主串中该字符进行比较的字符的位置。
得到 KMP 模式匹配算法的实现思路(区别就是 next 函数）
那么问题来了，如何实现 next数组 ，生成对于的 j回溯的位置，从前面的讨论可知，next数组值仅取决于模式串本身，而与主串无关。
j 的回溯距离d 等于模式串中临时匹配串长(也就是j） 减去 相同的前后缀子串中的最大子串长度S（两个最大子串的距离），next 的值就是 j - j + S =S因此要计算next函数的返回值，就要找出前缀和后缀相同的最大子串的长度。
这个查找过程实际上仍然是模式匹配，只是匹配的模式与目标在这里是同一个串S。（这里遵守 c 的规定，数组都是默认下标0开始存储）
//计算 next 数组：根据待匹配的字符串，求出对应每一位的最大相同前后缀的长度 void computeNext(char *str, int next[]) { } int strKMPCompare(char *strMain, char *strSub, int index, int next[]) { int iMain = index; int jSub = 0; int lenMain = getLength(strMain); int lenSub = getLength(strSub); while ((iMain >= 0 && iMain <= lenMain - 1) && ((jSub >= 0 && jSub <= lenSub - 1))){ if (strMain[iMain] == strSub[jSub]) { iMain++; jSub++; }else{ //主串的 i 不回溯！ //计算 next 数组 computeNext(strSub, &next[0]); jSub = next[jSub]; } } //如果匹配 ok，肯定子串先比完。 if (jSub > lenSub - 1) { return iMain - lenSub;//得到的就是匹配 ok 后，主串里第一个和模式串第一个字符匹配的字符的位置 }else{ return 0;//匹配失败 } }
那么最大的问题来了，如何实现 next数组？
next 数组递推的图解如下，已知，模式串的长度为 L ，j=0的时候，也就是第一个就不匹配， 规定next[0]=-1成立！其实在匹配过程中，若发生不匹配的情况，如果next[j]>=0，则目标串的指针i不变，将模式串的指针j移动到next[j]的位置继续进行匹配；若next[j]=-1，则将i右移1位，并将j置0，继续进行比较。
假设执行到某步，求出此时的 j （也就是第 j+1项发生不匹配）的 next[j] = k，k 是程序执行到这 步时，最长前后缀子串的长度。
如下是最长前缀子串：
P(0) P(1) …… P(K-1)
如下是模式串：
P(0) P(1) …… P(K-1) P(K) P(K+1) …… P(J-1) P(J) …… P(L - 1)
因为前后缀子串长度相等为 k，那么得到：
P(0) P(1) …… P(K-1) = P(J - K) …… P(J-1)
其中P(J - K) …… P(J-1)是最长后缀子串，长度是 k，注意满足j-1-j+k=k-1，直观的看就是：
P(0) P(1) …… P(K-1)
|| || || ||
P(J - K) …… P(J-1)
如果，对于模式串，继续求 j+1的 next[J+1]，如下：
P(0) P(1) …… P(K-1) P(K) P(K+1) …… P(J - K) …… P(J-1) P(J)
如果 p（k）=p（j），那么有：
P(0) P(1) …… P(K-1) P(K)
|| || || || ||
P(J - K) …… P(J-1) P(J)
此时，next[j+1]=k+1=next[j]+1
如果，p（k）!=p（j），那么需要从新检查，不过不论怎样计算，最后还是能得到一个正确的结果，即：最大重复前后缀字符串的前缀子字符串开头一定是 p（0），后缀字符串结尾一定是 p（j）。 但是在得到这个正确结果之前，我们总会经历相思的步骤，因为是找前后缀相等的子字符串，那么一般情况下总会经历这样的过程：前缀子字符串开头一定是 p（0），而已经知道后缀字符串的倒数第二项等于 p（k-1），那么前缀字符串的倒数第二项也应该等于 p（k-1），现在设为 p（m-1）来表示，又我们假设的是求出了next[j]=k，
P(0) P(1) …… p（m-1） …… P(K-1) P(K) P(K+1) …… P(J - K) …… P(J-1)
那么 j 之前的 每一位对应的 next 也都求出了，自然得到next[k-1]=m，此时前缀的结尾 p（m）要么满足和 p（j）相等，要么不相等，如相等还是m++处理，不等还是如上的过程，这样递归下去直到成功找到。
本质上则可以把其看做模式匹配的问题，即匹配失败的时候，k值如何移动
next[k-1]=m，next[m-1]=n，……，next[0]=0 =》
next[next[next[k-1]-1]-1……]=next[j+1] 且 next[j]=k
或
k++
实现代码
1 //计算 next 数组：根据待匹配的字符串，求出对应每一位的最大相同前后缀的长度 2 void computeNext(char *str, int next[]) 3 { 4 int k = -1;//记录最长前后缀字符串的长 5 int i = 1;// 6 //next【0】=-1，肯定要遍历模式串 7 next[0] = -1; 8 //模式串长度 9 int len = getLength(str); 10 //第一岑循环控制计算到模式串的每一位 11 while (i < len) { 12 //第二层循环，控制每次计算到某位置时，递归求解 k 的过程 13 //next[next[next[k-1]-1]-1……]=next[j+1] 且 next[j]=k 14 while (k > 0 && str[i] != str[k]) { 15 k = next[k - 1];//递归，逐层深入，调用 16 } 17 //i 变化，如果 stri=strk，退出递归循环，直接+1求解，否则一直递归到为k<=0退出 18 if (k == -1 || str[i] == str[k]) { 19 k++; 20 } 21 //所有情况都处理完毕，存储结果 22 next[i] = k; 23 i++; 24 } 25 }
需要注意几个点，因为规定了，next[0]=-1，那么 k 最小应该为-1，且若 next 返回-1的话，说明第一个不匹配，那么这里注意下，把 i++，j=0设置！在 kmp 函数里注意。
jSub = next[jSub]; if (jSub == -1 ) { jSub = 0; iMain++; }
在next 函数的 if 语句中，当 strk==stri， k++，但是还要注意，k==-1的情况！也要k++，否则紧跟 下面的 赋值，会把-1付给next【i】
完整代码
1 //计算 next 数组：根据待匹配的字符串，求出对应每一位的最大相同前后缀的长度 2 void computeNext(char *str, int next[]) 3 { 4 int k = -1;//记录最长前后缀字符串的长 5 int i = 1;// 6 //next【0】=-1，肯定要遍历模式串 7 next[0] = -1; 8 //模式串长度 9 int len = getLength(str); 10 //第一岑循环控制计算到模式串的每一位 11 while (i < len) { 12 //第二层循环，控制每次计算到某位置时，递归求解 k 的过程 13 //next[next[next[k-1]-1]-1……]=next[j+1] 且 next[j]=k 14 while (k > 0 && str[i] != str[k]) { 15 k = next[k - 1];//递归，逐层深入，调用 16 } 17 //i 变化，如果 stri=strk，退出递归循环，直接+1求解，否则一直递归到为k<=0退出 18 if (k == -1 || str[i] == str[k]) { 19 k++; 20 } 21 //所有情况都处理完毕，存储结果 22 next[i] = k; 23 i++; 24 } 25 } 26 27 int strKMPCompare(char *strMain, char *strSub, int index, int next[]) 28 { 29 int iMain = index; 30 int jSub = 0; 31 int lenMain = getLength(strMain); 32 int lenSub = getLength(strSub); 33 34 while ((iMain >= 0 && iMain <= lenMain - 1) && ((jSub >= 0 && jSub <= lenSub - 1))){ 35 if (strMain[iMain] == strSub[jSub]) { 36 iMain++; 37 jSub++; 38 }else{ 39 //主串的 i 不回溯！ 40 //计算 next 数组 41 computeNext(strSub, &next[0]); 42 jSub = next[jSub]; 43 if (jSub == -1 ) { 44 jSub = 0; 45 iMain++; 46 } 47 } 48 } 49 //如果匹配 ok，肯定子串先比完。 50 if (jSub > lenSub - 1) { 51 return iMain - lenSub;//得到的就是匹配 ok 后，主串里第一个和模式串第一个字符匹配的字符的位置 52 }else{ 53 return 0;//匹配失败 54 } 55 } 56 57 int main(int argc, const char * argv[]) { 58 char *str1 = "avcbababcc"; 59 char *str2 = "bab"; 60 int next[100] = {0}; 61 62 int i = strKMPCompare(str1, str2, 0 , &next[0]); 63 64 for (int i = 0; i < 11; i++) { 65 printf("%d \n", next[i]); 66 } 67 68 printf("%d\n", i); 69 70 return 0; 71 }
-1
0
1
0
0
0
0
0
0
0
0
3
Program ended with exit code: 0
补充：next数组的直接求法，上面说的是递归思想，递推关系。其实也可以直接求解。
思考:关键是如何比较，肯定需要知道模式串长 len，还需要头部一个标记，尾部一个标记。直接想到循环去遍历两个头，头++，尾部++，这是求的模式串的某个位置的 next 数组值。故还需要一个外循环控制依次遍历模式串。在这个外循环里，每趟循环，调用一次比较函数，求出 next[x]=？，通过 break 退出内部循环，实现一次调用。
1 //i 是前缀长，后缀长=i，故后缀第一个下标是 j-i ，通过比较函数内部的约束来调整参数 2 bool equal(char *str, int i, int j) 3 { 4 int head = 0;//假设是 0 1 …… i-1 和 j-i …… j-1，依靠，前后缀相等的特征！ 5 int tailHead = j - i;//参数 i 是前缀字符串的尾部下标，而前缀字符串长度就是 i，等于后缀字符串长度，故用末位 j-i 就是后缀字符串的开头 6 7 for (; head <= i - 1 && tailHead <= j -1; head++, tailHead++) { 8 if (str[head] == str[tailHead]) { 9 return true; 10 } 11 } 12 13 return false; 14 } 15 16 void getNext(char *str, int next[]) 17 { 18 int nextI = 0; 19 int head = 0; 20 21 for (; nextI < getLength(str) ; nextI++) { 22 //规定0是-1 23 if (0 == nextI) { 24 next[nextI] = -1; 25 }else if (nextI == 1){ 26 next[nextI] = 0; 27 } 28 else{ 29 //进行比较,需要一个循环控制 尾部字符串的处理 30 for (head = nextI - 1; head > 0; head--) { 31 //head 是头字符串的终点，nextI 是临时模式串的终点 32 if (equal(str, head, nextI)) { 33 next[nextI] = head; 34 break; 35 } 36 } 37 //别忘了要习惯性的思考边界的特例，如果 head--为0了，自动退出内循环，要处理下,其实是说明字符串没有任何重复字符出现的情况。 38 if (0 == head) { 39 next[nextI] = 0; 40 } 41 } 42 } 43 }
改进的 next数组 算法
在看一个例子：
主串：’aaabaaab’;
子串： aaaa3b
当子串中的第四个字符’a’与主串中的第四个字符’b’失配后，按照之前的 next 数组求法，的 next[3]=2如果用子串中的第3个字符’a’继续与主串中的第四个字符’b’比较，将是做无用功。以此类推。说明：kmp 算法里的关键next函数仍有改进的地方。改进next函数：当子串中的第j个字符与主串中的第i个字符失配后，如果有next[j]=k;且在子串中有pj=pk;那么pk肯定也与主串中的第i个字符不等，所以，直接让
next[j]=next[k];
直到他们不等或next[j] = -1为止。这个很好理解。当子串中的第四个字符’a’与主串中的第四个字符’b’失配后，next[3]=next[2]=1，则next[3]=next[1] = next[0] = -1。这样效率又高了些。
//所有情况都处理完毕，存储结果 if(str[i] == str[k]) { //本质还是把一个 k 赋值给了 next【i】，然后回到 while 处从新循环 next[i] = next[k]; }else{ next[i] = k; }
KMP算法只有在主串和模式串"部分匹配"时才会才会体现出他的优势，否则两者差异不大 ,KMP算法应用(可借鉴和参考的思想) 首先next数组代表每个字符在匹配失败时，回溯的位置，我们可以通过next数组找到每个字符的前缀和后缀
![[大语言模型-算法优化] 微调技术-LoRA算法原理及优化应用详解](https://ucc.alicdn.com/pic/developer-ecology/qy2cxr5w3tthc_33f1d390347b4adeb98b335ecc73ec77.jpeg?x-oss-process=image/resize,h_160,m_lfit)