数据结构4_java---顺序串，字符串匹配算法（BF算法，KMP算法）

1、顺序串

实现的操作有:

1. 构造串
2. 判断空串
3. 返回串的长度
4. 返回位序号为i的字符
5. 将串的长度扩充为newCapacity
6. 返回从begin到end-1的子串
7. 在第i个字符之前插入字串str
8. 删除子串

　　在实现返回位序号从begin到end-1的子串时，注意，此处串的起始位置为0，同时为了方便，我们再次没有新建一个变量，而是返回一个string，可以直接输出，在main函数中可以看到。

　　通过string.indexof()函数将字符数组转化为字符串。

　　同时在实现每个字符串的操作之前，先进行异常处理，避免出现越界现象。

curlen：表示当前字符串的长度

str：使用字符数组存放串值

 package Main;
 /*串的操作
  * */
 public class Main{
     public char[] str;               //使用字符数组存放串值
     public static int curlen;         //当前字符串的长度
     public Main()
     {
         str = new char[0];
         curlen = 0;
     }
     //以字符串常量构造串
     public Main(String string)
     {
         char[] a = string.toCharArray();
         str = a;
         curlen = a.length;
     }
     //以字符数组构造串
     public Main(char [] astr)
     {
         str = new char[astr.length];
         for(int i=0;i<astr.length;i++)
         {
             str[i] = astr[i];
         }
         curlen = str.length;
     }
     //将串变为空串
     public void clear()
     {
         curlen = 0;
     }
     //判断是否为空串
     public boolean isEmpty()
     {
         return curlen==0;
     }
     //返回串的长度
     public int length()
     {
         return curlen;
     }
     //返回位序号为i的字符
     public char charAt(int i)
     {
         System.out.println(curlen);
         if(i<0 || i>=curlen)
             throw new StringIndexOutOfBoundsException(i);
         return str[i];
     }
     //将串的长度扩充为newCapacity
     public void allocate(int newCapacity) {
         char [] tmp = str;
         str = new char[newCapacity];
         for(int i=0;i<tmp.length;i++)
         {
             str[i] = tmp[i];
         }
     }
     //返回位序号从begin到end-1的子串，注意，此处串的起始位置为0；
     public String subString(int begin,int end)
     {
         if(begin<0||begin>=end||end>curlen)
             throw new StringIndexOutOfBoundsException("the parameter is illegal!");
         char []tmp = new char[end-begin];
         for(int i=begin;i<end;i++)
         {
             tmp[i-begin]  = str[i];
         }
         return String.valueOf(tmp);
     }

     //在第i个字符之前插入字串str
     public void insert(int i,String aString)
     {
         if(i<0||i>curlen)
             throw new StringIndexOutOfBoundsException("the inserted location is illegal");
         int len = aString.length();
         int newcapacity = len + curlen;
         allocate(newcapacity);            //重新分配存储空间
         for(int j=curlen-1;j>=i;j--)      //移动数据元素
         {
             str[j+len] = str[j];
         }

         for(int j=i;j<i+len;j++)
         {
             str[j] = aString.charAt(j-i);
         }

     }
     //删除操作
     public void delete(int begin,int end)
     {
         if(begin<0||end>curlen||begin>=end)
             throw new StringIndexOutOfBoundsException("the parameter is illegal!");
         for(int i=begin;i<end-1;i++)
         {
             str[i] = str[i+end-begin];
         }
         curlen = curlen-end+begin;
     }
     //打印字符串
     public void print()
     {
         for(int i=0;i<str.length;i++)
         {
             System.out.print(str[i]);
         }
         System.out.println();
     }
     public static void main(String[] args) {
         Main aMain = new Main("hello world");
         String aString = "thank you";
         System.out.println(curlen);
         System.out.println("if the string is empty:"+aMain.isEmpty());
         System.out.println("the length of this string:"+aMain.length());
         System.out.print("the character of the serial number betweent one and three is :");
         System.out.println(aMain.subString(1, 4));
         aMain.print();
         aMain.insert(2, aString);
         aMain.print();

     }
 }

2、BF算法

　　属于暴力破解字符串匹配问题，将所有的情况遍历一边，所用的时间复杂度比较大，个人偏向于后面的KMP算法。

（1）外层一个循环指示主串的指针，内层一个for循环用于指示模式串，j作为模式串指针从零开始，至模式串的长度。

（2）分为两种情况:

• 如果当前字符不匹配，则跳出循环，继续读取主串的下一个字符，即i++;
• 如果匹配完毕，则j = len（模式串长度）-1，则输出结果

 public static void BF(String aString,String bString)
     {
         int i = 0,j = 0;
         int len_a = aString.length();
         int len_b = bString.length();
         while(i<=len_a-len_b)
         {
             for(j=0;j<len_b;j++)
             {
                 if(bString.charAt(j)!=aString.charAt(j+i))
                 {
                     i++;
                     break;
                 }else if(j==len_b-1){

                     System.out.println("BF algorithm:"+i);
                     return ;
                 }
             }
         }
         System.out.println("matching failed!");
     }

3、KMP算法

该算法的主要思想为当某次匹配失败时主串的开始比较位置不回退，而是利用部分字符匹配的结果将模式串向右移动较远的距离后再进行比较

算法分析：

(1)  K值的计算，即计算next[]值,此处作用于模式串本身，和主串无关

• 初始时设next[0] = -1,next[1] = 0,k=0,j=1;
• 设next[j] = k ,则p₀p₁p₂....p_k-1 = p_j-kp_j-k+1p_j-k+2......p_j-1,注意，此处直到k-1和j-1处，k为满足该等式的最大值，此时计算next[j+1]的值
  • 若pk = pj ,则存在p₀p₁p₂....p_k = p_j-kp_j-k+1p_j-k+2......p_j，此时next[j+1] = k+1;
  • 若pk ≠ pj，则把计算next[j]的值的问题看做新的模式匹配过程，主串为P,模式串为P的前缀子串
    • 出现不匹配时，应该将模式串的比较位置变为k' = next[k]，若pj = pk',则next[j+1] = k'+1 = next[k] + 1
    • 否则继续执行上述步骤，直到pj = pk .或者当k=0且pj≠pk时，next[j+1] = 0;

 public int[] next(String p)
     {
         int []next = new int[p.length()];    //next[]数组
         int k=0;              //模式串指针
         int j=1;              //主串指针
         next[0] = -1;next[1] = 0;
         while(j<p.length()-1)
         {
             if(p.charAt(j)==p.charAt(k))
             {
                 next[j+1] = k+1;
                 j++;
                 k++;
             }else if (k==0) {
                 next[j+1] = 0;
                 j++;
             }else
                 k = next[k];
         }
         return next;
     }

(2)  KMP算法步骤

• 计算模式串的next[]的值
• i为主串的比较字符位序号，j为模式串的比较字符串位序号。当字符相等时，i,j分别加1后继续比较，否则i的值不变，j = next[j],继续比较
• 特殊情况，当j = =0时，i++,主串字符位开始移动;
• 重复步骤2，直到j等于模式串的长度是匹配成功，否则匹配失败

public int KMP(String s,String p)
    {
        int []next = next(p);
        int j=0,i=0;
        while(i<s.length()&&j<=p.length())
        {
            if(j==-1||s.charAt(i)==p.charAt(j))
            {
                i++;
                j++;
            }else if(j==0)
            {
                i++;
            }else {
                j = next[j];
            }
            if(j==p.length())
                return i-p.length();
        }
        return -1;
    }

（3）应用

主串为s = “abcabccabc” , 模式串为t = "bcc"；

分别使用BF算法和KMP算法实现

 package Main;

 import java.util.Scanner;

 /*串的操作
  * */
 public class Main{
     public char[] str;
     public int cur;
     public static void BF(String aString,String bString)
     {
         int i=0,j=0;
         int len_a = aString.length();
         int len_b = bString.length();
         while(i<=len_a-len_b)
         {
             for(j=0;j<len_b;j++)
             {
                 if(aString.charAt(i+j)!=bString.charAt(j))       //如果不匹配则跳出循环，继续读取原字符串的下一个字符
                 {
                     i++;
                     break;
                 }else if (j==len_b-1)                             //匹配完毕
                 {
                     System.out.println("BF algorithm:"+i);
                     return ;
                 }
             }
         }
         System.out.println("The string matching failed!!");
     }
 //KMP算法第一步，求解next值
     public static int[] next(String bString)
     {
         int []next = new int[bString.length()];
         next[0] = -1;
         next[1] = 0;
         int k=0;
         int j=1;
         int len = bString.length();
         while(j<len-1)
         {
             if(bString.charAt(k)==bString.charAt(j))
             {
                 next[j+1] = k+1;
                 k++;
                 j++;

             }else if(k==0)
             {
                 next[j+1] = 0;
                 j++;
             }else {
                 k = next[k];
             }
         }
         return next;
     }
     //KMP算法第二步，匹配位置
     public static void KMP(String aString,String bString)
     {
         int []next = next(bString);
         int i=0;
         int j=0;
         while(i<aString.length()&&j<bString.length())
         {
             if(j==-1||aString.charAt(i)==bString.charAt(j))
             {
                 i++;
                 j++;
             }else if(j==0)
             {
                 i++;
             }else {
                 j = next[j];
             }

         }
         if(j==bString.length())
         {
             System.out.println("KMP algorithm:"+(i-bString.length()));
         }
     }

     public static void main(String[] args) {
         Scanner aScanner = new Scanner(System.in);
         //可输入四次
         int i=4;
         String aString,bString;
         while(i!=0) {
             System.out.println("Please input the main String:");
             aString = aScanner.next();
             System.out.println("Please input a String to match:");
             bString = aScanner.next();
             BF(aString,bString);
             KMP(aString,bString);
             i--;
         }

     }
 }