zoukankan      html  css  js  c++  java
  • [leetcode] 101. Symmetric Tree 对称树

    题目大意

    #!/usr/bin/env python
    # coding=utf-8
    # Date: 2018-08-30
    
    """
    https://leetcode.com/problems/symmetric-tree/description/
    
    101. Symmetric Tree
    
    Given a binary tree, check whether it is a mirror of itself (ie, symmetric around its center).
    
    For example, this binary tree [1,2,2,3,4,4,3] is symmetric:
    
        1
       / 
      2   2
     /  / 
    3  4 4  3
    But the following [1,2,2,null,3,null,3] is not:
        1
       / 
      2   2
          
       3    3
    Note:
    Bonus points if you could solve it both recursively and iteratively.
    
    """
    
    # Definition for a binary tree node.
    class TreeNode(object):
        def __init__(self, x):
            self.val = x
            self.left = None
            self.right = None
    
    class Solution(object):
        def isSymmetric(self, root):
            """
            :type root: TreeNode
            :rtype: bool
            """

    解题思路

    关键点:左子树和右子树成镜像关系,根树与本身成镜像关系。

    Approach 1: Recursive 递归法

    A tree is symmetric if the left subtree is a mirror reflection of the right subtree.

    Therefore, the question is: when are two trees a mirror reflection of each other?

    Two trees are a mirror reflection of each other if:

    1. Their two roots have the same value.
    2. The right subtree of each tree is a mirror reflection of the left subtree of the other tree.

    This is like a person looking at a mirror. The reflection in the mirror has the same head, but the reflection's right arm corresponds to the actual person's left arm, and vice versa.

    The explanation above translates naturally to a recursive function as follows. 

     Java解法:

    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解法:

    class Solution(object):
        def isSymmetric(self, root):
            return self.is_mirror(root, root)
    
        def is_mirror(self, t1, t2):   # Recursive
            if not t1 and not t2:
                return True
            if not t1 or not t2:
                return False
            return (t1.val == t2.val) and self.is_mirror(t1.left, t2.right) and self.is_mirror(t1.right, t2.left)

    Complexity Analysis

    • Time complexity : O(n)O(n). Because we traverse the entire input tree once, the total run time is O(n)O(n), where nn is the total number of nodes in the tree.
    • Space complexity : The number of recursive calls is bound by the height of the tree. In the worst case, the tree is linear and the height is in O(n)O(n). Therefore, space complexity due to recursive calls on the stack is O(n)O(n) in the worst case.

    Approach 2: Iterative 迭代法

    Instead of recursion, we can also use iteration with the aid of a queue. Each two consecutive nodes in the queue should be equal, and their subtrees a mirror of each other. Initially, the queue contains root and root. Then the algorithm works similarly to BFS, with some key differences. Each time, two nodes are extracted and their values compared. Then, the right and left children of the two nodes are inserted in the queue in opposite order. The algorithm is done when either the queue is empty, or we detect that the tree is not symmetric (i.e. we pull out two consecutive nodes from the queue that are unequal).

    Java解法:

    public boolean isSymmetric(TreeNode root) {
        Queue<TreeNode> q = new LinkedList<>();
        q.add(root);
        q.add(root);
        while (!q.isEmpty()) {
            TreeNode t1 = q.poll();
            TreeNode t2 = q.poll();
            if (t1 == null && t2 == null) continue;
            if (t1 == null || t2 == null) return false;
            if (t1.val != t2.val) return false;
            q.add(t1.left);
            q.add(t2.right);
            q.add(t1.right);
            q.add(t2.left);
        }
        return true;
    }

    Python解法:

    class Solution(object):
        def isSymmetric(self, root):  # Iterative
            queue = [root, root]
            while queue:
                t1, t2 = queue.pop(), queue.pop()
                if not t1 and not t2:
                    continue
                if not t1 or not t2 or t1.val != t2.val:
                    return False
                queue.extend([t1.left, t2.right, t1.right, t2.left])
            return True

    Complexity Analysis

    • Time complexity : O(n)O(n). Because we traverse the entire input tree once, the total run time is O(n)O(n), where nn is the total number of nodes in the tree.
    • Space complexity : There is additional space required for the search queue. In the worst case, we have to insert O(n)O(n) nodes in the queue. Therefore, space complexity is O(n)O(n).

    参考:https://leetcode.com/problems/symmetric-tree/solution/

  • 相关阅读:
    模块三 GO语言实战与应用-条件变量sync.Cond(上)
    模块三 GO语言实战与应用-sync.Mutex与sync.RWMutex
    模块三 GO语言实战与应用-更多的测试手法
    模块三 GO语言实战与应用-测试的基本规则和流程(下)
    模块三 GO语言实战与应用-测试的基本规则和流程(上)
    模块二 GO语言进阶技术-PANIC函数、RECOVER函数以及DEFER语句(下)
    CentOS7 相关命令-sunziren
    Thymeleaf如何回填复选框?-sunziren
    Thymeleaf中如何判断字符串是否包含或者不包含某个子串?-sunziren
    MySQL Innodb Engine--修改数据时先写Buffer Pool还是先写Redo Log
  • 原文地址:https://www.cnblogs.com/bymo/p/9558703.html
Copyright © 2011-2022 走看看