KMP算法的C语言代码实现

    KMP算法的C语言代码实现
//
//核心思想：匹配过程中匹配不等时，不需回溯i指针，而是利用已经得到的“部分匹配”结果将模式向右“滑动”尽可能远的一段距离继续比较。
//******************************************************************************************************************************

#include <stdio.h>
 
#include <string.h>
int index_KMP(char *s,char *t,int pos); 
//利用模式串的t的next函数求t在主串s中的第pos个位置之后的位置的KMP算法（t非空，1<=pos<=Strlength(s)）。
void get_next(char * t,int * next); 
//求模式串t的next函数的并存入数组next[]中。
char s[20]="adjfskjfskdjsfkglsi";
char t[5]="skdj";
int next[5];
int pos=0;
void main()
{ 
       int n; 
       get_next(t,next);
       n=index_KMP(s,t,pos);
       if(n!=0)
       printf("\n模式串 t 在主串 s 中第 %d 个位置之后。\n\n",n); 
      else
      printf("\n主串中不存在与模式串相匹配的子串!\n\n");
}
int index_KMP(char *s,char *t,int pos) 
//利用模式串的T的NEXT函数求t在主串s中的第pos个位置之后的位置的KMP算法，（t非空，1<=pos<=Strlength(s)）.
{ 
      int i=pos,j=1;
     while (i<=(int)strlen(s)&&j<=(int)strlen(t))
     { 
             if (j==0  ||  s[i]==t[j-1]) //继续进行后续字符串的比较
             {      
                 i++; 
                 j++; 
             }
            else j=next[j]; //模式串向右移动
   }
  if (j>(int)strlen(t)) //匹配成功
  return i-strlen(t)+1;
 else //匹配不成功 
 return 0; 
}
void get_next(char *t,int *next) 
//求模式串t的next函数的并存入数组next[]中。
{
      int i=1,j=0;
      next[0]=next[1]=0;
      while (i<(int)strlen(t)) 
      { 
             if (j==0 || t[i]==t[j]) 
             { 
                  i++; 
                  j++; 
                  next[i]=j; 
             } 
      else j=next[j];
    }
}

---

/**//*
NO.1
O(n^2)的算法：
*/
/**//*枚举主串的每一个位置开始比较*/

#include <stdio.h>

#define MAX 101

int main(void)
...{
    char a[MAX],b[MAX];
    int la=0,lb=0,i,j,k ;
    char c  ;
     
    while ( (c =getchar())!= ' ')
    a[++la] = c ;
    while ( (c =getchar())!= ' ')
    b[++lb] = c ;
    
    for(i=1 ; i<=la ; i++)
    ...{
            for(j=1,k=i; j<= lb && (b[j] == a[k]) ; j++,k++) ;
            if ( j > lb )
            break ;
    }
    
    if ( j > lb)
    printf("No.%d ",i);
    else
    printf("No Soulation!!! ");
             
            
    
    system("pause");   
    return 0 ;
}

/**/ /*
No.2  O(a+b) 的算法：该算法是由knuth 等三个人想出来的，简称为：KMP 算法
基本思想是：
一般的算法为什么这么低效呢？那是因为主串指针回溯情况过多:
主串指针如果不回溯的话，速度就会加快，那我们就会想：
如何让主串指针不回溯？
KMP算法就是解决了这个问题，所以速度变得更快速了
它是这样子的：
用一个数组：next[] 求得失配时的位置，然后保存下来，具体请看如下程序：

*/
*/

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#define MAX 101


void get_next( int *next,char *a,int la) /**//*求NEXT[]的值*/
...{
     int i=1,j=0 ;
     next[1] = 0 ;
     
     while ( i <= la) /**//*核心部分*/
     ...{
           if( a[i] == a[j] || j == 0 )
           ...{
               j ++ ;
               i ++ ;
               if( a[i] == a[j])
               next[i] = next[j];
               else
               next[i] = j ;
           }
           else
           j = next[j] ;
     }
}

int  str_kmp( int *next, char *A ,char *a, int lA,int la)/**//* EASY*/
...{
     int i,j,k ;
     i = 1 ;
     j = 1 ;
     while ( i<=lA && j <= la )
     ...{
           if(A[i] == a[j] ||  j == 0 )
           ...{
                   i ++ ;
                   j ++ ;
           }
           else
           j = next[j] ;
     }
     
     if ( j> la)
     return i-j+1 ;
     else
     return -1 ;
}

int main(void)
...{
    int n,k;
    int next[MAX]=...{0} ;
    int lA=0,la =0 ;
    char A[MAX],a[MAX] ;
    scanf("%s %s",A,a) ;
    
    lA = strlen(A);
    la = strlen(a);
    for(k=la-1; k>= 0 ;k --)
    a[k+1] = a[k] ;
    for(k=lA-1; k>= 0 ;k --)
    A[k+1] = A[k] ;
    
    get_next(next,a,la) ;
    k = str_kmp(next,A,a,lA,la);
    if ( -1 == k)
    printf("Not Soulation!!! ");
    else
    printf("%d ",k) ;
    system("pause");
    
    return 0 ;
}

---

下面这个一般的回溯算法验证可以使用：

子串匹配——回溯算法

子串的匹配是一个很常见的问题，意思就是说在一个给定的大字符串中寻找给定的子字符串。这是一个很经典的问题，包括一代宗师D.Knuth都在这个问题上有很深入的研究，并提出了所谓的KMP算法。当然这个问题的一个最直观的算法就是这里给出的回溯法。

回溯法求解子串的过程为：依次遍历大字符串和子串，当发现不相等的时候就回溯到上次起始字符的下一个字符继续，并给子串起始位置清零。当遍历完整个大字符串（没有找到）或者遍历完子串（找到）则算法退出。

实现源码为：

int FindSubString(const char* src,const char* sub)
{
       int srcl = strlen(src);
       int subl = strlen(sub);
< xmlnamespace prefix ="o" ns ="urn:schemas-microsoft-com:office:office" /> 
       if (subl > srcl)
              return -1;
 
       int i = 0;
       int j = 0;
 
       while ((i < srcl) && (j < subl))
       {
              if (src[i] == sub[j])
              {
                     i++;
                     j++;
              }
              else
              {
                     i = i - j + 1;  //回溯，位置确定请根据已遍历字符串长度为基点计算
                     j = 0;
              }
       }
 
       if (j >= subl)
       {
              return i - subl;
       }
      
       return -1;
 
}