看起来简单实际上却很牛的KMP算法：LeetCode572-另一棵树的子树

题目描述

给定两个非空二叉树 s 和 t，检验 s 中是否包含和 t 具有相同结构和节点值的子树。s 的一个子树包括 s 的一个节点和这个节点的所有子孙。s 也可以看做它自身的一棵子树。

暴力解法

从s的根节点开始遍历，查看该节点下的子树是否与t相同。方法是同步对s和t进行遍历，一旦出现s和t有不同（包括只有其中一个为NULL，或都不为NULL时value不同），就返回为false。如果最终返回给调用比较函数的地方是false，那么就继续为s的下一个节点重新遍历。

class Solution {
public:
    bool isSameTree(TreeNode * sNow, TreeNode * tNow)
    {
        if(!sNow && !tNow) return true;
        if((!sNow && tNow) || (sNow && !tNow) || (sNow->val != tNow->val)) 
        return false;
        //这里直接返回的是：当左子树和右子树全部相等时，就是匹配的。
        //为什么没有比较本节点？因为假如本节点value不一样，就已经在上面一个if被返回false了，不会执行到最后的return
        return isSameTree(sNow->left, tNow->left) && isSameTree(sNow->right, tNow->right);
    }

    bool dfs(TreeNode * sNow, TreeNode * tNow)
    {
        if(!sNow) return false;
        //由于||和&&的短路特性，||后面的表达式只有前面为false才会被运行
        return isSameTree(sNow, tNow) || dfs(sNow->left, tNow) || dfs(sNow->right, tNow);
    }

    bool isSubtree(TreeNode* s, TreeNode* t) {
        bool isSub = dfs(s, t);
        return isSub;
    }
};

显然暴力解法的复杂度太高了。其时间复杂度为O(|s|*|t|)，其中|s|和|t|是s树和t树的节点数量。空间复杂度方面，递归栈最大为O(max{d_s, d_t})，其中d_s, d_t分别是s和t的最大深度。

遍历后匹配字符串

为了解决暴力解法复杂度高的问题，一个容易想到的思路是首先对s和t前序遍历之后形成数组（字符串），然后再来进行字符串的匹配。

这样会出现一个显而易见的问题，当t是s的“一部分”而并非子树时，也就是t的“底端”比s多一些节点时，会出现匹配失误的情况。为了解决该问题，可以将叶节点左、右节点的NULL也插入到字符串中，这样可以保证匹配唯一。

遍历过后，就成为了一个字符串匹配问题。我们把较长的需要寻找子串的一个叫做文本串S（此处是s树得来的），匹配的目标叫做模式串P（此处是t树得来的）。

直接匹配

进行字符串匹配时，首先可以从暴力匹配想起。其思路是：对于S[i], P[j]，如果匹配，则继续往后一位匹配。如果失配，则S退回到i = i-j+1，也就是与j开始匹配的后一位，P退回到j = 0，重新开始匹配过程。

此算法的浪费之处在于，假如失配时S[i-j+1]与S[i-j]并不相同，那么P重新从S[i-j+1]开始匹配时必然是失配的，在找到下一个匹配开始点前的操作都是重复的。

KMP算法匹配

KMP算法原理

KMP算法的核心在于利用了已经匹配过的信息。其关键在于加入了一个next数组。

next数组的意义是：next[k]表示从模式串的子串P[0]到P[k]中，相同前缀后缀的最大长度。例如：P = ABCDFABGF，那么next[6] = 2，即子串ABCDFAB的相同前缀后缀最长是AB，长度为2。

有了next数组，如果首位失配则S[i]后移(i++)，如果非首位失配，则下次迭代只要从S[i]和P[next[j]]开始即可。因为在失配处的前面子串里，长度为next[j]的后缀是跟前缀一样的，这next[j]位必定是匹配的，无需再次迭代。

next数组求解

那么还剩下一个问题，next数组如何求解？

首先直观的方式是直接索引长度为1、2、3……的开头和结尾串，直到长度j-1的子串。其计算的重复性也是显而易见的。

较好的方法是使用动态规划。思考一下，当已知next[0…j]时，如何求出next[j+1]的值？

令k = next[j]，即从开头算起长度为j的子串，最长的相同前缀后缀长度为k。此时有两种情况：

1. p[k] = p[j]：即之前的前后缀再往后看一格，也是相同的。所以此时这个长度就增加了1，即next[j+1] = k + 1。
2. p[k] ≠ p[j]：则令k = next[k]，即在原本的最长相同前缀子串里再寻找它的最长相同前缀，重复第一步。意思是说，对于p[j+1]，如果之前的相同前后缀再加一位是不相同的，那么再到这个前缀里去找，能不能找到？这样循环往复，直到最开始为止。

class Solution {
private:
    int maxElement,lNULL, rNULL;
    vector<int> sValues, tValues;
public:
    void getMaxElement(TreeNode *p)
    {
        if(!p) return;
        maxElement = max(maxElement, p->val);
        getMaxElement(p->left);
        getMaxElement(p->right);
    }

    void traverse(TreeNode * p, vector<int> & stack)
    {
        if(!p) return;
        stack.push_back(p->val);

        if(p->left == NULL)
            stack.push_back(lNULL);
        else
            traverse(p->left, stack);

        if(p->right == NULL)
            stack.push_back(rNULL);
        else
            traverse(p->right, stack);
    }

    bool kmp()
    {
        int i = 0, j = 0;
        int sLen = sValues.size(), tLen = tValues.size();
        vector<int> next(tLen, 0);
        
        //首先计算next数组
        for(int k = 1; k < tLen; k++)
        {
            int index = k;
            while(index > 0)
            {
                if(tValues[k] == tValues[next[index - 1]])
                {
                    next[k] = next[index - 1] + 1;
                    break;
                }
                else
                {
                    index = next[index - 1];
                }
            }
            if(index <= 0) next[k] = 0;
        }

        //从头开始匹配字符串，失配后使用next数组重新尝试匹配
        while(i < sLen && j < tLen)	
        {
            if(j == 0)
            {
                while(sValues[i] != tValues[j] && i < sLen)
                    i++;
            }

            if(sValues[i] == tValues[j])
            {
                i++;
                j++;
            }
            else
            {
                if(j > 0)
                    j = next[j - 1];
                else
                    j = 0;
            }
        }
        if(j == tLen)
            return true;
        return false;
    }

    bool isSubtree(TreeNode* s, TreeNode* t) {
        maxElement = INT_MIN;
        getMaxElement(s);    //找出s和t中的最大值，分别+1 +2作为左右NULL值
        getMaxElement(t);
        lNULL = maxElement + 1;
        rNULL = maxElement + 2;

        traverse(s, sValues);    //对s，t进行前序遍历
        traverse(t, tValues);

        return kmp();
    }
};