ZBox字符串匹配算法

Zbox 的意思：一个字符串 S ，它的子串 S[i..n], 用 Z[i] 表示 S[i..n] 与 S 精确匹配的最长前缀的长度。如：abcdabce , Z[5] = 3。

如图 1：

       1 2 3 4 5 6 7 8

       a b c d a b c e

       |___|   |___|

                  zbox

 那么如何把 S 中所有的 Z[i] 找出来呢？并且让它的时间是线性的。

 如图 2：

       |____|___|_____________|____|___|______|

       1    22  31           100  121  130    n

            k'                     |_g_|

                                     k    

 

    Z[100] = 31，求 Z[121] = ?

 可以看出，因为 Z[100] = 31, 所以 S[100..130] 与 S[1..31] 是相同的，显然 S[22..31] 与 S[121..130] 也是相同的。那么，是不是可以通过 Z[22] 来求 Z[121] 呢？

 答案是，当 Z[22] < 10 的时候，Z[22] = Z[121]; 而当 Z[22] >= 10的时候，Z[22] <= Z[121], Z[121]真正的值，还需要通过比较 S[131..n] 这些后面的字符才能算出。

 由上面的例子得出 Zbox 算法：

 设 k 为 S 的任意一个位置，循环从 k=2 到 k=n-1。

 设 r 是 当前 Zbox 覆盖的最靠右的位置，l 是 当前 r 所属的 Zbox的左起点。

 1. 若 k > r, 则 k 未落在当前覆盖最远的 Zbox 中，所以不能用现成的 Z[i] 值，只好老老实实地比较 S[1..n] 和 S[k..n]，直到不能匹配的位置 q ，则 Z[k] = q-k ，l = k，r = q-1。

 2. 若 k <= r, 则 k 落在了当前覆盖最远的 Zbox 中， 所以可以利用上之前已经计算好的 Z[i] 值。但是还要分两种情况。设 g=r-k+1。如图2。

    a. 如果 Z[k'] < g ，则 Z[k]=Z[k'];

    b. 如果 Z[k'] >= g，则需要从第 r+1 个字符开始检验，直到不能匹配的字符q，则 Z[k] = q-k ，l = k ，r = q-1 。 

 

利用上述 Zbox 算法，就可以在文本 T 中发现所有与 p 精确匹配的子串了。

int ZBoxMatch(byte* pSrc, int nSrcSize, byte* pSubSrc, int nSubSrcSize)
{
    int* pZBox = new int[nSrcSize];
    pZBox[0] = 1;
    int left = 0, right = 0;
    for( int i = 0; i < nSrcSize; i++)
    {
        if(i > right)
        { 
            //ZBox之外,更新ZBox的区间 
            int j = 0;
            while(j + i < nSrcSize && pSubSrc[j] == pSrc[i+j])
            {
                j++;
            }
            left = i;
            right = i + j - 1;
            pZBox[i] = j;
        }
        else 
        {
            //ZBox之内 
            int p = i - left;
            if(pZBox[p] < right - i + 1)
            {
                //p的最长公共前缀匹配不超过right与i的宽度 
                pZBox[i] = pZBox[p];
            }
            else 
            {
                //否则接着right 向后继续计算匹配的位置 
                int j = right + 1;
                while(j < nSrcSize && pSubSrc[j] == pSrc[j - i])
                {
                    j++;
                }
                left = i;
                right = j - 1;
                pZBox[i] = j - i;
            }
        }
    }
    int nPos = -1;
    for( int i = 0; i < nSrcSize; i++)
    {
        if (pZBox[i] == nSubSrcSize)
        {
            nPos = i;
            break;
        }
    }
    delete[] pZBox;
    return nPos;
} 

时间复杂度分析： 因为 T 和 P 的字符至多被比较了一次，所以时间复杂度是 O(m+n)，|P| = m，|O| = n。

空间复杂度分析： O(m)。