day14

226 翻转二叉树

给你一棵二叉树的根节点 root ，翻转这棵二叉树，并返回其根节点。
#问题在于弄清楚为什么使用前序遍历后序遍历，不用中序遍历，因为有可能翻转两次结点

class TreeNode(object):
    def __init__(self,val=0,left=None,right=None):
        self.val = val
        self.left = left
        self.right = right
class Solution(object):
    def invertTree(self, root):
        """
        :type root: TreeNode
        :rtype: TreeNode
        """
        ##使用前序遍历
        if root == None:
            return 
        root.left,root.right = root.right,root.left
        self.invertTree(root.left)
        self.invertTree(root.right)
        return root
        

101 对称二叉树

给你一个二叉树的根节点 root ， 检查它是否轴对称。

要比较两个节点数值相不相同，首先要把两个节点为空的情况弄清楚！否则后面比较数值的时候就会操作空指针了。

节点为空的情况有：（注意我们比较的其实不是左孩子和右孩子，所以如下我称之为左节点右节点）

左节点为空，右节点不为空，不对称，return false
左不为空，右为空，不对称 return false
左右都为空，对称，返回true
此时已经排除掉了节点为空的情况，那么剩下的就是左右节点不为空：

左右都不为空，比较节点数值，不相同就return false
此时左右节点不为空，且数值也不相同的情况我们也处理了。

class TreeNode():
    def __init__(self,val=0,left=None,right=None):
        self.val = val
        self.left = left
        self.right = right
class Solution(object):
    def isSymmetric(self, root):
        """
        :type root: TreeNode
        :rtype: bool
        """
        if root == None:
            return True
        return self.compare(root.left,root.right)
    def compare(self,left,right):
        if left == None and right != None:
            return False
        elif left != None and right == None:
            return False
        elif left == None and right == None:
            return True
        elif left.val != right.val:
            return False
        
        #此时才是左右节点均不为空，且数值相同
        outside = self.compare(left.left,right.right)
        inside = self.compare(left.right,right.left)
        insame = outside and inside
        return insame

总结：主要还是一个思路问题，二叉树分为左右两侧，分别进行判断

104 二叉树的最大深度

class Solution(object):
    def maxDepth(self, root):
        """
        :type root: TreeNode
        :rtype: int
        """
        return self.getdepth(root)
    def getdepth(self,node):
        if node == None:
            return 0
        leftheight = self.getdepth(node.left)
        rightheight = self.getdepth(node.right)
        height = 1 + max(leftheight,rightheight)
        return height

111 二叉树的最小深度

class TreeNode(object):
    def __init__(self, val=0, left=None, right=None):
        self.val = val
        self.left = left
        self.right = right
class Solution(object):
    def minDepth(self, root):
        """
        :type root: TreeNode
        :rtype: int
        """
        return self.getDepth(root)
    def getDepth(self,node):
        if node is None:
            return 0
        leftDepth = self.getDepth(node.left)
        rightDepth = self.getDepth(node.right)

        if node.left is None and node.right is not None:
            return 1 + rightDepth

        if node.right is None and node.left is not None:
            return 1 + leftDepth

        result =  1 + min(leftDepth,rightDepth)
        return result        

层序遍历法：

import collections
class Solution(object):
    def minDepth(self, root):
        """
        :type root: TreeNode
        :rtype: int
        """
        if root == None:
            return 0
        depth = 0
        queue = collections.deque([root])

        while queue:
            depth += 1
            for _ in range(len(queue)):
                node = queue.popleft()
                if node.left == None and node.right == None:
                    return depth
                if node.left:
                    queue.append(node.left)
                if node.right:
                    queue.append(node.right)
            
        return depth