LeetCode刷题——11th

难度：简单/Easy

序号与题目：100——相同的树

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

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

示例 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

思考：针对两棵树的根节点，有下列四种情况：p 和 q 都为空，两棵树相同；p 不为空 q 为空，两棵树不相同；p 为空 q 不为空，两棵树不相同；p 和 q 都不为空，如果两个节点的值相同，而且递归判断左右子树也相同的话，两棵树相同，反之两棵树不同。

实现：

C

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     struct TreeNode *left;
 *     struct TreeNode *right;
 * };
 */
bool isSameTree(struct TreeNode* p, struct TreeNode* q) 
{
    if(p==NULL && q==NULL)
    {
        return true;
    }
    if(p!=NULL && q!=NULL && p->val==q->val  )
    {
        return isSameTree(p->left,q->left) && isSameTree(p->right,q->right);
    }
    else 
    {
        return false;
    }
}

C++

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution 
{
public:
    bool isSameTree(TreeNode* p, TreeNode* q) 
    {
         if(p==NULL && q==NULL)
             return true;
        if(p!=NULL && q!=NULL && p->val==q->val  )
        {
            return isSameTree(p->left,q->left) && isSameTree(p->right,q->right);
        }
        else 
        {
            return false;
        }
    }
};

Java

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
class Solution 
{
    public boolean isSameTree(TreeNode p, TreeNode q) 
    {
        if(p==null && q==null)
        {
        return true;
        }
        if(p!=null && q!=null && p.val==q.val  )
        {
            return isSameTree(p.left,q.left) && isSameTree(p.right,q.right);
        }
        else 
        {
            return false;
        }
    }
}

Python

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None

class Solution:
    def isSameTree(self, p, q):
        """
        :type p: TreeNode
        :type q: TreeNode
        :rtype: bool
        """
        if not p and not q:
            return True
        elif p is not None and q is not None:
            if p.val == q.val:
                return self.isSameTree(p.left, q.left) and self.isSameTree(p.right, q.right)
            else:
                return False
        else:
            return False

序号与题目：101——对称二叉树

给定一个二叉树，检查它是否是镜像对称的。
例如，二叉树 [1,2,2,3,4,4,3] 是对称的。
    1
   / \
  2   2
 / \ / \
3  4 4  3
但是下面这个 [1,2,2,null,3,null,3] 则不是镜像对称的:
    1
   / \
  2   2
   \   \
   3    3
说明:
如果你可以运用递归和迭代两种方法解决这个问题，会很加分。

思考：如果两棵树均为空，返回为真。一棵树为空，一棵树不为空，返回为假。两个树都不为空，根的值不同，返回为假，根的值相同，对于同一位置的根，判断一棵树根的左子树的值是否与另一棵树的右子树的值，或者是判断一棵树根的右子树的值是否与另一棵树的左子树的值，不同返回假，相同则判断下一个根（递归）

实现：

C

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     struct TreeNode *left;
 *     struct TreeNode *right;
 * };
 */
bool dfs(struct TreeNode* t1, struct TreeNode* t2) 
{
    if (!t1 && !t2)
        return true;
    if (!t1 || !t2)
        return false;
    if (t1->val != t2->val)
        return false;
    return dfs(t1->left, t2->right) && dfs(t1->right, t2->left);
}
bool isSymmetric(struct TreeNode* root) 
{
    if (!root)
        return true;
    return dfs(root->left, root->right);
}

C++

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution 
{
public:
    bool isSymmetric(TreeNode* root) 
    {
        return ismirror(root,root);
    }
    bool ismirror(TreeNode* p,TreeNode* q)
    {
        if(!p&&!q)//都为NULL
            return true;
        if(!p||!q)//有一个为NULL
            return false;
        if(p->val==q->val)
            return ismirror(p->left,q->right)&&ismirror(p->right,q->left);
        return false;
    }
};

Java

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
class Solution 
{
    public boolean isSymmetric(TreeNode root) 
    {
    return isMirror(root, root);
    }
    public boolean isMirror(TreeNode t1, TreeNode t2) 
    {
        if (t1 == null && t2 == null) return true;
        if (t1 == null || t2 == null) return false;
        return (t1.val == t2.val)
            && isMirror(t1.right, t2.left)
            && isMirror(t1.left, t2.right);
    }
}

Python

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None

class Solution:
    def isSymmetric(self, root):
        """
        :type root: TreeNode
        :rtype: bool
        """
        if root:
            return self.digui(root.left,root.right)
        else:
            return True
        
        def digui(self,q,p):
            if q and p:
                return q.val==p.val and self.digui(q.left,p.right) and self.digui(q.right,p.left)
            else:
                return not q and not p