刷Leetcode算法的第十六天

序言

DFS-深度优先搜索算法，用于遍历或搜索树或图的算法。沿着树的深度遍历树的节点，尽可能深的搜索树的分支。当节点v的所在边都己被探寻过，搜索将回溯到发现节点v的那条边的起始节点。 本质其实是递进的思想。
用几个简单的题目来理解DFS

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

例子如下：

输入:       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

def isSameTree(self, p: TreeNode, q: TreeNode) -> bool:
        #当两方的第一个节点 是None的时候，开始比较 
        #当两个节点都是None的时候，一样的-True
        if p is None and q is None: return True 
        #当其中有一方是None 不一样-False
        elif p is None or q is None: return False  
              
        #当第一个节点有值的时候 开始比较
        if p.val != q.val:return False        
        #开始递进，继续比较这个节点的左边和右边
        return self.isSameTree(p.left,q.left) and self.isSameTree(p.right,q.right)

---

题目：给定一个二叉树，检查它是否是镜像对称的

例子：

输入：
    1
   / \
  2   2
 / \ / \
3  4 4  3
输出：
True

输入：
    1
   / \
  2   2
   \   \
   3    3
输出：
True

思路是 采用DFS的方式，计划套入递进模式，即从root的左右开始递进，一直探索，如果探索的过程中一旦有不一样的树枝，即刻返回错误，如果探到底都没有返回错误的树枝，那么，到底的时候，全部都是None，都返回True。
代码如下：

    def isSymmetric(root: TreeNode):

        #如果开头节点是None，就直接是True
        if root is None: return True 

        def check(node1,node2):
            #谈论有None的问题
            if node1 is None and node2 is None: return True 
            elif node1 is None or node2 is None: return False 
            #讨论数值的问题 
            if node1.val != node2.val: return False 
            #递进
            return check(node1.left, node2.right) and check(node1.right, node2.left)

        return check(root.left, root.right)

---

题目：给定一个二叉树，找出其最大深度。
二叉树的深度为根节点到最远叶子节点的最长路径上的节点数。
说明: 叶子节点是指没有子节点的节点

例子如下：

    3
   / \
  9  20
    /  \
   15   7
输出：
3
最长深度是3 

class Solution:
    def maxDepth(self, root: TreeNode) -> int:
        if root is None: return 0 
        #因为root也是一个长度
        return max(self.maxDepth(root.left),self.maxDepth(root.right))+1