0007 另一个树的子树

另一个树的子树

编号：0007

题目来源：leetcode

题目描述

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

树的结构如下：

struct TreeNode {
     int val;
     TreeNode *left;
     TreeNode *right;
     TreeNode() : val(0), left(nullptr), right(nullptr) {}
     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 };

示例

解答算法

官方解答传送门

递归检查

自己写的思路如下

算法思路

因为要求判断$s$中是否含有$t$这样的子树，那也就是说，如果含有就会有$s$的一个子树和$t$完全一样。所以可以递归的进行判断：如果$s$和$t$相同，那么显然返回true，如果不同，再分别那$s$的左子树和右子树和$t$进行比较，如果其中有相同的也返回$true$，一直递归到最后$s$变成$NULL$，递归终止。

代码实现

class Solution {
public:
	bool isSubtree(TreeNode* s, TreeNode* t) {  //判断是否为子树的递归调用
		if (s == NULL)              //空子树，递归终止
			return false;
		if (ifTheSame(s, t))        //如果检查s和t一样，返回true
			return true;
		return (isSubtree(s->left, t) || isSubtree(s->right, t));//检查左右子树
	}
	bool ifTheSame(TreeNode* s, TreeNode* t)  //判断两个树是否完全相同，也是递归判断
	{
		if (s == NULL && t == NULL)          
			return true;
		else if ((s == NULL && t != NULL) || (s != NULL && t == NULL))
			return false;
		if (s->val == t->val)
			return (ifTheSame(s->left, t->left) && ifTheSame(s->right, t->right));
		return false;
	}
};

官方题解

class Solution {
public:
    bool check(TreeNode *o, TreeNode *t) {
        if (!o && !t) return true;
        if ((o && !t) || (!o && t) || (o->val != t->val)) return false;
        return check(o->left, t->left) && check(o->right, t->right);
    }

    bool dfs(TreeNode *o, TreeNode *t) {
        if (!o) return false;
        return check(o, t) || dfs(o->left, t) || dfs(o->right, t);
    }

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

复杂度分析

时间复杂度：整个过程中总的时间是遍历s树的时间和每次比较的时间相乘，即$O(s\times t)$

空间复杂度：整个过程中用了两个递归函数，isSubtree更多依赖于s树的深度，ifTheSame更多依赖于t树的深度，最后的空间复杂度就是两者的较大值

$DFS$序列上进行串匹配

算法思路

先序遍历(DFS)生成的序列中，子树是连续的，因此可以通过判断t生成的DFS序列是否是s的DFS的序列的子串。

但是这样做是不完全正确的，因为还存在即使是子串，但是左右位置发生变化，例如1是根，2是左孩子和1是根，2是右孩子的DFS序列相同，但是不是一个树，因此需要添加两个空值lNull和rNull，生成DFS序列之后，就可以进行子序列的匹配了。

代码实现

class Solution {
public:
    vector <int> sOrder, tOrder;  //用来存放两个DFS序列
    int maxElement, lNull, rNull;

    void getMaxElement(TreeNode *o) {  //得到树o的最大节点值，放入全局变量maxElement中，递归调用
        if (!o) return;
        maxElement = max(maxElement, o->val);
        getMaxElement(o->left);
        getMaxElement(o->right);
    }

    void getDfsOrder(TreeNode *o, vector <int> &tar) { //得到树o的DFS序列，放入tar中，递归调用
        if (!o) return;
        tar.push_back(o->val);
        if (o->left) getDfsOrder(o->left, tar);
        else tar.push_back(lNull);
        if (o->right) getDfsOrder(o->right, tar);
        else tar.push_back(rNull);
    }

    bool kmp() {
        int sLen = sOrder.size(), tLen = tOrder.size();
        vector <int> fail(tOrder.size(), -1);
        for (int i = 1, j = -1; i < tLen; ++i) {
            while (j != -1 && tOrder[i] != tOrder[j + 1]) j = fail[j];
            if (tOrder[i] == tOrder[j + 1]) ++j;
            fail[i] = j;
        }
        for (int i = 0, j = -1; i < sLen; ++i) {
            while (j != -1 && sOrder[i] != tOrder[j + 1]) j = fail[j];
            if (sOrder[i] == tOrder[j + 1]) ++j;
            if (j == tLen - 1) return true;
        }
        return false;
    }

    bool isSubtree(TreeNode* s, TreeNode* t) {
        maxElement = INT_MIN;
        getMaxElement(s);
        getMaxElement(t);
        lNull = maxElement + 1;
        rNull = maxElement + 2;

        getDfsOrder(s, sOrder);
        getDfsOrder(t, tOrder);

        return kmp();
    }
};

用到了$KMP$算法，有丢丢不好理解，丢一个我觉得讲的很好的连接：CSDN，理解了他画红的，基本上就理解了KMP算法。

复杂度分析

• 时间复杂度：由于使用了KMP算法，因此最终事件复杂度$O(s+t)$，递归遍历两棵树的时间之和
• 空间复杂度：保存了两个DFS序列，辅助空间代价$O(s+t)$，两个栈空间，是 O ( m a x { d s , d t } ) O(max\{d_s,d_t\}) O(max{ds​,dt​})，两棵树的深度的较大值，因此求和还为$O(s+t)$

官方的hash算法我不太懂，就不贴了