kmp算法

1. // 模式串最大长度  
2. const int MAX_P_LEN = 1024;  
3. // next数组，next[i]代表模式串前缀pattern[0-i]的最大公共前后缀  
4. // 同时，next[i]也代表当模式串在第i个位置字符失配时，下一次应该用来与当前位置的文本串字符继续比较的模式串字符位置  
5. int next[MAX_P_LEN];  
6.   
7. // 构建模式串pattern的next数组值  
8. void getFail(char pattern[])  
9. {  
10.     int PatLen = strlen(pattern);  
11.     // 初始化递推边界  
12.     next[0] = 0;  
13.     next[1] = 0;  
    
14.     // 构建模式串pattern的每一个前缀的next值，即计算其最大公共前后缀的长度  
15.     for(int i=1; i<PatLen; ++i)  
16.     {  
17.         int j = next[i];  
18.         // 在前缀中递推搜寻  
19.         while(j && pattern[i]!=pattern[j]) j = next[j];  
20.         next[i+1] = pattern[i]==pattern[j] ? j+1 : 0;  
21.     }  
22. }
23. 分别从文本串和模式串的第一个字符开始判断，如果相等则比较下一个字符，否则失配时则按照对应位置的next值移动模式串重新进行比较，直到判断完所有的模式串字符则匹配成功，判断完所有的文本串字符则整个匹配过程结束。
24. 1. // 用于判断文本串text中是否包含模式串pattern  
    2. int kmp(char text[], char pattern[])  
    3. {  
    4.     int TextLen = strlen(text);  
    5.     int PatLen = strlen(pattern);  
    6.     // 当前比较的模式串字符位置  
    7.     int j = 0;  
    8.     // 比较文本串的每一个字符  
    9.     for(int i=0; i<TextLen; ++i)  
    10.     {  
    11.         // 失配时沿着失配边走，直到可以匹配或回到模式串的第一个字符  
    12.         while(j && text[i]!=pattern[j]) j = next[j];  
    13.         // 比较当前文本串字符和移动后的模式串当前字符  
    14.         if (text[i] == pattern[j]) ++j;  
    15.         // 如果模式串的所有字符都比较相等了，则完成模式匹配  
    16.         if (j == PatLen) return 1;  
    17.     }  
    18.     return 0;  
    19. }
    1. // 用于判断模式串pattern在文本串text中出现了多少次  
    2. int kmp_times(char text[], char pattern[])  
    3. {  
    4.     int times = 0;  
    5.     int TextLen = strlen(text);  
    6.     int PatLen = strlen(pattern);  
    7.     // 当前比较的模式串字符位置  
    8.     int j = 0;  
    9.     // 比较文本串的每一个字符  
    10.     for(int i=0; i<TextLen; ++i)  
    11.     {  
    12.         // 失配时沿着失配边走，直到可以匹配或回到模式串的第一个字符  
    13.         while(j && text[i]!=pattern[j]) j = next[j];  
    14.         // 比较当前文本串字符和移动后的模式串当前字符  
    15.         if (text[i] == pattern[j]) ++j;  
    16.         // 如果模式串的所有字符都比较相等了，则完成模式匹配  
    17.         if (j == PatLen)  
    18.         {  
    19.             ++times;  
    20.             // 移动模式串  
    21.             j = next[j];  
    22.         }  
    23.     }  
    24.     return times;  
    25. }