KMP算法的具体实现

我打算重新开始学习数据结构C语言版。今天看到的KMP算法。硬是把我绕进去了。主要是书上给的代码短小精悍，硬是看不懂怎么回事。

KMP算法的主要思想是即是利用部分匹配的思想，当匹配不同的时候，两个指针不用回溯到初始位置，对于主串中的指针就是不用回溯到开始匹配模式串的位置，对于模式串的指针就是不用回到模式串的头位置。主串中的指针无需回溯，而模式串中的指针则是根据相应next函数值，回溯到某个位置即可，这样算法时间复杂度就可以降低为O(n+m)。
核心部分就是求出模式串中的next函数值。

下例中数组均以 1 开始。

对于next[i] = j 来说，则说明 模式串中的前 ( j - 1 )个字符 和 从( i - 1)开始往前( j - 1 )个字符相匹配。定义next[1] = 0;此时
1. 若 t[i] = t[j] ，则说明next[ i + 1] = next[ i ] + 1。前 j 个字符都匹配。
2. 若 t[i] != t[j] ，则说明此时 对于第 ( i + 1) 个字符(t[i+1])来说，前面的 第 j 个字符匹配不成功。
      此时应该缩小匹配长度，即令 j = next [ j ]，如果此时相等的话，此时next [ i + 1] = next [ j ] + 1。如果不相等就进入循环。如果到最后都不相等则令next [ i + 1 ] = 1。（即回到模式串的头位置）

//-----本书中的字符串数组的第一个为数组长度 如下 T的长度为 T[0];
//-----以下为类C语言的算法描述
void get_next(SString T,int 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];
}

实在不知所云。于是我要先自己实现一遍，即便代码很丑…，再细细琢磨才行。

//此处是C语言实现的。代码可以运行。
// int nt 为模式串的长度，char t[] 为模式串。

void get_next(char t[],int nt,int next[]){
    int i = 1;//计数器：为当前匹配字母位置。（ 0 开头的数组 ） 
    next[0] = -1;
    next[1] = 0;
    int temp = next[i];
    for(;i < nt;){
        printf("next[% d]= %d\n",i,next[i]);
        if(t[i] == t[next[i]]){
            next[i+1] = next[i] + 1;
            i++;
            temp = next[i];
            printf("t[j]=t[k]：直接加一：t[i] + 1\n");

        }else if(t[i] == t[temp]){

            if( temp == 0){

                printf("t[j] = t[0]：当和第一个字母匹配时，从第二个开始匹配：0\n");
                next[i + 1] = 1;
            } 
            else{
                printf("t[j] = t[next..]：当和某个t[temp]匹配时：next[temp]+1\n");
                next[i+1] = next[temp] + 1;
            }
            i++;
            temp = next[i];
        }else if(temp < 0){

            printf("temp < 0 :当无法匹配时，从第一个开始匹配：0 \n",temp);
            next[i+1] = 0;
            i++;
            temp = next[i];
        }else {
                printf("进入循环，使得temp=next[temp]\n");

                temp = next[temp];

        }

    }

再来理解一下上面伟大的短代码：

void get_next(SString T,int next[]){
i = 1;//------for i = 1 to Tlength(T(0)-1),计算每个next[i]的值
next[1] = 0;
j = 0;//j用来控制循环，j 始终等于 next[j],当符合条件时候，就 ++i ++j,然后赋值给next[i+1]。
while(i < T[0]){
    if(j == 0 || T[i] == T[j]){ 
    ++i; ++j; next[i] = j;
    //上面一行即等价于 next[i + 1] = j + 1;i++;
    //也许会更好理解一点。
    }
    else j = next[j];
}

下面我再把第一次写的C代码改善一下：

//这里C语言实现，因为在算法中next[1]规定为0。在这里我可以规定 使得 next[0] = -1
//使其字符数组和next[]的计数都可以从0开始。免去一些麻烦。
void get_next(char t[],int nt ,int next[]){
    int i = 0,j = -1;
    next[0] = -1;
    while( i < nt - 1){
        if(j == -1 || t[i] == t[j]){
            i++;
            j++;
            next[i] = j;
        }
        else j = next[j];
    }
}

例题：（来自牛客网）
对于两棵彼此独立的二叉树A和B，请编写一个高效算法，检查A中是否存在一棵子树与B树的拓扑结构完全相同。
给定两棵二叉树的头结点A和B，请返回一个bool值，代表A中是否存在一棵同构于B的子树。

思路：即对两个二叉树进行深度优先序列化，然后用KMP算法进行比较是否含有子串。

import java.util.*;

/*
public class TreeNode {
    int val = 0;
    TreeNode left = null;
    TreeNode right = null;
    public TreeNode(int val) {
        this.val = val;
    }
}*/
public class IdenticalTree {
    public boolean chkIdentical(TreeNode A, TreeNode B) {
        // write code here
       String stra = toSerializale(A);

       String strb = toSerializale(B);

        char[] sa = stra.toCharArray();
        char[] sb = strb.toCharArray();

       return kmp(sa,sb) != -1;
    }
    public static String toSerializale(TreeNode head){
        StringBuilder str = new StringBuilder();
        if(head == null) return "#!";

        str.append(head.val);
        str.append(toSerializale(head.left));
        str.append(toSerializale(head.right));

        return str.toString();
    }
    public static int kmp(char[] a,char[] b){

        int[] next = new int[b.length];
        getNext(b,next);


        int i = 0,j = 0;
        while(i < a.length && j < b.length){
            if(j == -1 || a[i] == b[j]) {i++;j++;}
            else j = next[j];
        }


        if(j >= b.length) return i - b.length;
        return -1;
    }
    public static void getNext(char[] a,int[] next){
        int i = 0;
        int j = -1;
        next[0] = -1;


        while(i < a.length - 1){
            if(j == -1 || a[i] == a[j]) { i++; j++; next[i] = j;}
            else j = next[j];
        }

    }
}

其实java里面很多算法都已经实现了，所以上述完全可以不用自己写kmp算法 ，而是直接用indexOf即可。如下：

 public boolean chkIdentical(TreeNode A, TreeNode B) {
        // write code here
       String stra = toSerializale(A);

       String strb = toSerializale(B);

       return stra.indexOf(strb) != -1;
    }