字符串模式匹配

字符串模式匹配，即字串的定位操作。就是判断主串S中是否存在给定的子串，如果存在，那么返回子串在S中的位置，否则返回0。

实现这种操作有两种算法：

朴素的模式匹配算法

S长度为n，T长度为m。

思路
 对于主串的每个字符，做长度为`strlen(T)` 的循环，判断是否与子串匹配。
 最好的情况就是一开始就匹配成功，时间复杂度O(1)；
 最坏的情况就是每次匹配失败都是在T的最后一个元素，复杂度O(n*m);
 平均情况复杂度O(n + m)。

 1 /*下标从0开始，查找从第pos个位置开始*/
 2 #include <stdio.h>
 3 #include <string.h>
 4 int Index(char S[], char T[], int pos)
 5 {
 6  int i = pos;       //i记录S当前下标
 7  int j = 0;          //j记录T当前下标
 8  while (i < strlen(S) && j < strlen(T))
 9  {
10   if (S[i] == T[j])
11   {
12    i++;
13    j++;
14   }
15   else
16   {
17    i = i - j + 1;   //i退回到上次匹配首字母的下一位
18    j = 0;          //j退回到T开始
19   }
20  }
21  if (j == strlen(T))
22   return i - j;
23  else
24   return -1;
25 }
26 int main(int argc, char** argv)
27 {
28  char s[] = "Hello World!";
29  char t[] = "World";
30  printf("%d\n",Index(s, t, 0));
31  return 0;
32 }

View Code

KMP算法

众所周知，计算机处理的都是二进制数据，那么所有的0，1串如果都采用朴素的模式匹配，实在低效~
所以大佬们觉得遍历这种做法实在low，D.E. Knuth, J.H. Morris, V.R. Pratt就提出了KMP算法来优化传统的匹配算法。

思路

KMP主要分两步：

 1. 进行T的自匹配
这一步关键在于得到Next数组，从T的第一位开始对自身匹配，在某一位置能匹配的最长长度即是当前位置Next值。
而Next数组则是由PMT数组后移一位得到，将`Next[0] = -1`。
那么PMT又是什么呢？
PMT(Partial Match Table)-----部分匹配表。

> PMT中的值是字符串的前缀集合与后缀集合的交集中最长元素的长度。

 2. S与T的匹配
这步的匹配和朴素匹配没有太大差异，只是S串的指针不用回溯，而将j回溯到Next[j]位置。

 1 #include <stdio.h>
 2 #include <string.h>
 3 /*计算next数组*/
 4 void next_compute(char T[], int* next)
 5 {
 6  int i = 0, j = -1;
 7  next[0] = -1;
 8  while (i < strlen(T))
 9  {
10   if (-1 == j || T[i] == T[j]) //自匹配
11   {
12    i++;
13    j++;
14    next[i] = j;
15   }
16   else               //字符不同，j值回溯
17   {
18    j = next[j];
19   }
20  }
21 }
22 int KMP(char S[], char T[], int pos)
23 {
24  int next[255];
25  int i = pos, j = 0;
26  int Slen, Tlen;
27  next_compute(T, next);
28  Slen = strlen(S);
29  Tlen = strlen(T);
30 /*此处while循环条件不能用strlen，strlen()不能与负数比较大小*/
31  while (i < Slen && j < Tlen)
32  {
33   if (-1 == j || S[i] == T[j])
34   {
35    i++;
36    j++;
37   }
38   else
39   {
40    j = next[j];            //j回退到合适位置
41   }
42  }
43  if (j == strlen(T))
44   return i - j;
45  else
46   return -1;
47 }
48 int main(int argc, char** argv)
49 {
50  char s[] = "hello world!";
51  char t[] = "world";
52  printf("%d\n",KMP(s, t, 0));
53  
54  return 0;
55 }

View Code

改进KMP算法

主要改进了Next数组。

 1 /*计算next数组*/
 2 void next_compute(char T[], int* next)
 3 {
 4     int i = 0, j = -1;
 5     next[0] = -1;
 6     while (i < strlen(T))
 7     {
 8         if (-1 == j || T[i] == T[j]) //自匹配
 9         {
10             i++;
11             j++;
12             if (T[i] != T[j])
13                 next[i] = j;
14             else
15                 next[i] = next[j];
16         }
17         else               //字符不同，j值回溯
18         {
19             j = next[j];
20         }
21     }
22 }

View Code

 

转载于:https://www.cnblogs.com/EIMadrigal/p/9248215.html