[NEO解题报告]《Leetcode》100 --相同的树

1. 题目信息

1.1 题目描述

题目链接： 100. 相同的树

给你两棵二叉树的根节点 p 和 q ，编写一个函数来检验这两棵树是否相同。
如果两个树在结构上相同，并且节点具有相同的值，则认为它们是相同的。

1.2 测试用例

• 示例 1：
• 

输入：p = [1,2,3], q = [1,2,3]
输出：true

• 示例 2：
• 

输入：p = [1,2], q = [1,null,2]
输出：false

• 示例 3：
  

输入：p = [1,2,1], q = [1,1,2]
输出：false

• 提示：

两棵树上的节点数目都在范围 [0, 100] 内
-104 <= Node.val <= 104

来源：力扣（LeetCode） 链接：https://leetcode-cn.com/problems/same-tree
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

2. 题目分析

仔细审题，给定的树的节点在100范围内， oh yeah， 这个说明是允许进行递归的；
给定的比较方法是看结构和每个节点的值， 与判定链表中是否有相同节点（那种相同是指针就相同）方法不一样， 必须遍历检查所有的节点才行； 所以问题转换为 遍历树， 并比较树的结构， 所谓的结构就是每一层节点的左右子节点个数是否完全一致；

2.1 dfs递归遍历比较

递归代码写起来最直观和方便， 能用递归就能用栈模拟， 如果数据量不允许递归， 那就只有用栈来模拟了， 此处是简单题目直接递归； 用栈模拟的， 欢迎查阅后续的数据结构和常用算法专辑；

• 确定结束条件， 两个树的节点都是空指针， 返回true；
• 有一个树的节点不为空， 说明结构不一样， 返回 false；
• 检查节点值 并且 递归判定左右子树， 搞定收工！

2.2 bfs入队列比较

直接建立两个队列， 并且同时做相同操作， 最后都为空则一致， 其中一个不为空则不一样， 中间每个步骤都可以适当剪枝提前退出判定；

• 在 C++ 中可以使用 queue ; 在 python 中建议用 deque；

【循环执行下面的4歌步骤】：

1. 同时取出队头节点， 判定是否节点值相同；
2. 判定两者左子节点存在性是否一致， 同时空或者同时非空；
3. 判定两者右子节点存在性是否一致， 同时空或者同时非空；
4. 非空的左右子节点入队列

3. 代码详情

3.1 C++

3.1.1 dfs递归遍历比较方法

/**
 * Definition for a binary tree node.
 * 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) {}
 * };
 */
class Solution {
public:
    bool isSameTree(TreeNode* p, TreeNode* q) {
        // 执行用时：4 ms, 在所有 C++ 提交中击败了52.27%的用户
        // 内存消耗：9.8 MB, 在所有 C++ 提交中击败了21.28%的用户
        if (p == nullptr && q == nullptr) {
            return true;
        }
        if (p == nullptr || q == nullptr) {
            return false;
        }
        return p->val == q->val && isSameTree(p->left, q->left) && isSameTree(p->right, q->right);
    }
};

3.1.2 bfs队列方法

• 这个代码也还好写，没啥可优化的， 直接看官方题解吧， 这里简单注释一下；

class Solution {
public:
    bool isSameTree(TreeNode* p, TreeNode* q) {
        if (p == nullptr && q == nullptr) {
            return true;
        } else if (p == nullptr || q == nullptr) {
            return false;
        }
        queue <TreeNode*> queue1, queue2;
        queue1.push(p);
        queue2.push(q);
        while (!queue1.empty() && !queue2.empty()) {
        	// 步骤1, 同时取出头结点判定值是否相同
            auto node1 = queue1.front();
            queue1.pop();
            auto node2 = queue2.front();
            queue2.pop();
            if (node1->val != node2->val) {
                return false;
            }

			// 步骤2, 判定两者左子节点存在性是否一致， 同时空或者同时非空；
            auto left1 = node1->left, right1 = node1->right, left2 = node2->left, right2 = node2->right;
            if ((left1 == nullptr) ^ (left2 == nullptr)) {
                return false;
            }
            // 步骤3, 判定两者右子节点存在性是否一致， 同时空或者同时非空；
            if ((right1 == nullptr) ^ (right2 == nullptr)) {
                return false;
            }

			// 步骤4, 非空的左右子节点入队列
            if (left1 != nullptr) {
                queue1.push(left1);
            }
            if (right1 != nullptr) {
                queue1.push(right1);
            }
            if (left2 != nullptr) {
                queue2.push(left2);
            }
            if (right2 != nullptr) {
                queue2.push(right2);
            }
        }
        return queue1.empty() && queue2.empty();
    }
};

// 作者：LeetCode-Solution
// 链接：https://leetcode-cn.com/problems/same-tree/solution/xiang-tong-de-shu-by-leetcode-solution/
// 来源：力扣（LeetCode）
// 著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

3.2 Python

3.2.1 dfs递归遍历比较

class Solution:
    def isSameTree(self, p: TreeNode, q: TreeNode) -> bool:
	    # 执行用时：44 ms, 在所有 Python3 提交中击败了36.86%的用户
		# 内存消耗：15 MB, 在所有 Python3 提交中击败了8.47%的用户
        if not p and not q:
            return True
        if not p or not q:
            return False

        return  p.val == q.val and self.isSameTree(p.left, q.left) and self.isSameTree(p.right, q.right)

3.2.2 bfs队列方法

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution:
    def isSameTree(self, p: TreeNode, q: TreeNode) -> bool:
	    # 执行用时：36 ms, 在所有 Python3 提交中击败了84.49%的用户
		# 内存消耗：15 MB, 在所有 Python3 提交中击败了7.26%的用户
        if not p and not q:
            return True
        if not p or not q:
            return False

        dq1 = collections.deque([p])
        dq2 = collections.deque([q])
        while dq1 and dq2:
            node1 = dq1.popleft()
            node2 = dq2.popleft()
            if node1.val != node2.val:
                return False
            
            left1, left2 = node1.left, node2.left
            if (not left1) ^ (not left2):
                return False
            
            right1, right2 = node1.right, node2.right
            if (not right1) ^ (not right2):
                return False

            if left1:
                dq1.append(left1)
            if right1:
                dq1.append(right1)

            if left2:
                dq2.append(left2)
            if right2:
                dq2.append(right2)
        return not dq1 and not dq2

4. 系列文章

• [NEO解题报告]《Leetcode》00 - 汇总