演算法目的：確定子串在主串中第一次出現的位置

兩種演算法:BF,KMP(重點掌握)

一:BF演算法

1.特點：主串的指標需回溯,速度慢;

2.演算法思想:

       當主串T(長為m)和子串S(長為n)的比較字元不相等時，主串的指標i需要指向之前開始比較的位置的後面一個字元(相應的子串的指標j需要重新指到1),,這樣依次拿子串T和主串的一個連續子字串比較知道兩個串相等為止。

int Index_BF(SString S, SString T, int pos)//pos為從哪個位置開始找,設兩個字串下標都是從1開始
{
   if(pos<=0||T.length<=0)return 0;//非法操作
   int i=pos,j=1;
   while(i<=S.length&&j<=T.length)
   {
     if(S.ch[i]==T.ch[j])
        {i++;j++}
     else
        {
          i=i-j+2;j=1;
        }
   } 
   if(j>T.length)
      return i-T.length; //或者i-j+1
   else
      return 0;//沒找到
}
 

   最好情況:只需比較一次，即比較子串的長度的次數n=O(n);

  最差情況:每次比較時都發現子串的最後一個字元和主串不相等,故需要比較(m-n)*n+n=(m-n+1)*n=O(m*n)次

 一般情況:O(m+n);//要從最好到最壞情況統計總的比較次數，然後取平均。

二.KMP演算法(詳細推理過程本人依然不是很理解，不過以下的掌握了就大致能意會了):

1.特點:比較時，主串的指標i不需要回溯，只需把子串向右滑動若干距離

2.思想:儘量利用已經部分匹配的結果資訊，儘量讓i不要回溯，加快模式串的滑動速度。

3.求k=next[j]:

      1).j表示正在比較的子串和主串的失配的位置,k=next[j]表示下一次主串應該和子串比較的時候子串的字元指標所在的位置;

      2).next[j]函式象徵著模式T中最大相同字首子串和字尾子串（真子串）的長度。
       可見，模式中相似部分越多，則next[j]函式越大，它既表示模式T字元之間的相關度越高，也表示j位置以前與主串部分匹配的字元數越多。
      即：next[j]越大，模式串向右滑動得越遠，與主串進行比較的次數越少，時間複雜度就越低（時間效率）。

      3).求法:（推導見<<資料結構>>原文）

4程式碼實現(求next[j]函式):

void get_next(SString T, int  &next[ ] )
{ 
    //求模式串T的next函式值並存入陣列next[ ]。
    i=1;  next[1]=0; j=0;
    while(i<T[0] )
    {
       if(j= = 0||T[i]= =T[j]){++i; ++j; next[i]=j;}
       else j=next[j];
     }
}// get_next
 

Int Index_KMP(SString S, SString T, int pos)//與BF演算法比較(類似)
{   
   if(pos<=0||T.length<=0)return 0;//非法操作
   i=pos;j=1; 
   while ( i<=S.length && j<=T.length) 
   {
      if (j==0|| S.ch[i] = = T.ch[j] ) {++i, ++j} //不失配則繼續比較後續字元
      else {j=next[j];
   } //特點：S的i指標不回溯，而且從T的k位置開始匹配 
   if(j>T.length)
           return i-T.length; //子串結束，說明匹配成功 else 
   return 0;//沒找到}//Index_KMP

   1).我們假設主串T為 a a a b a a a a b,

                   子串S為 a a a a b;

       求得S的next[j]=0,1,2,3,4;

   我們可以自己模擬上面的完整的KMP演算法，發現當主串的指標i和子串的指標j都指向4時，此時失配，j=next[4]=3,又發現失配,j=next[3]=2,又失配.....依次j指向0，然後i=5,j=1,才匹配，在此過程中我們可以發現KMP演算法並沒有起到作用，那是因為子串存在很多相同的字首，導致主串不匹配的字元與子串比較了多次,即next[j]的函式不完善!!!!

 2).完善的next[j]演算法:

void get_nextval(SString T, int  &nextval[ ] )
{
    //next函式修正值存入陣列nextval
    i=1;  nextval[1]=0; j=0;
    while(i<T[0] )
    {
      if(j= = 0||T[i]= =T[j] )
       { ++i;++j;
         If(T[i]!=T[j] ) nextval[i]=j;
         else nextval[i]=nextval[j]; 
       }
      else j=nextval[j]; 
    }
}// get_nextval

        由於指標i無須回溯，比較次數僅為m,即使加上計算next[j]時所用的比較次數n，比較總次數也僅為m+n=O(m+n)，大大快於BF演算法。