Leetcode每日一题(20200807)

今日题目

T100 相同的树(简单，递归，搜索)

题目描述

给定两个二叉树，编写一个函数来检验它们是否相同。

如果两个树在结构上相同，并且节点具有相同的值，则认为它们是相同的。

示例 1:
输入:      1        1
         /  \      / \
        2    3    2   3
[1,2,3],   [1,2,3]
输出: true

示例 2:
输入:      1          1
          /           \
         2             2
[1,2],     [1,null,2]
输出: false

示例 3:

输入:      1         1
          / \       / \
         2   1     1   2
[1,2,1],   [1,1,2]
输出: false

标签

递归，深度优先搜索，广度优先搜索

解析

略

python解法

#dfs
class Solution:
    def isSameTree(self, p: TreeNode, q: TreeNode) -> bool:
        if p == None:
            return q == None
        if q == None:
            return False
        if p.val != q.val:
            return false
        return self.isSameTree(p.left, q.left) and self.isSameTree(
            p.right, q.right)

#bfs
class Solution:
    def isSameTree(self, p: TreeNode, q: TreeNode) -> bool:
        if p == None:
            return q == None
        if q == None:
            return False
        q1 = collections.deque([p])
        q2 = collections.deque([q])
        while q1:
            node1 = q1.popleft()
            node2 = q2.popleft()
            if node1.val != node2.val:
                return False
            if node1.left and node2.left:
                q1.append(node1.left)
                q2.append(node2.left)
            elif not (not node1.left and not node2.left):
                return False
            if node1.right and node2.right:
                q1.append(node1.right)
                q2.append(node2.right)
            elif not (not node1.right and not node2.right):
                return False
        return True

C++解法

//dfs
class Solution
{
public:
    bool isSameTree(TreeNode *p, TreeNode *q)
    {
        if (p == nullptr)
        {
            return q == nullptr;
        }
        if (q == nullptr)
        {
            return false;
        }
        if (p->val != q->val)
        {
            return false;
        }
        return (isSameTree(p->left, q->left) && isSameTree(p->right, q->right));
    }
};

//bfs
class Solution {
public:
    bool isSameTree(TreeNode* p, TreeNode* q) {
        if (p==nullptr && q==nullptr)
            return true;
        if (p==nullptr)
            return false;
        if (q==nullptr)
            return false;
        queue<TreeNode*>q1, q2;
        q1.push(p);
        q2.push(q);
        while (q1.size()>0) {
            auto node1 = q1.front();
            auto node2 = q2.front();
            q1.pop();
            q2.pop();
            if (node1->val != node2->val)return false;
            if (node1->left!=nullptr && node2->left!=nullptr) {
                q1.push(node1->left);
                q2.push(node2->left);
            }
            else if (node1->left==nullptr && node2->left==nullptr)
                ;
            else
                return false;
            if (node1->right!=nullptr && node2->right!=nullptr) {
                q1.push(node1->right);
                q2.push(node2->right);
            }
            else if (node1->right==nullptr && node2->right==nullptr)
                ;
            else
                return false;
        }
        return true;
    }
};

备注

推荐直接递归+dfs