深度优先搜索

深度优先搜索

深度优先搜索：包括先根遍历（根->左 ->右）， 中根遍历（左-> 跟->右）， 后根遍历（左-> 右->根) 3种

思路：

使用递归来进行遍历

一般当遍历到叶子结点时返回（if not node: return)

如果想得到左子树的左叶子结点 ,一般将根的左子树传入递归函数，当遍历到左叶子节点就会返回

同理，想得到右子树的右叶子结点，将跟的右子树传入递归函数，当遍历到右叶子节点时返回

1. 二叉树是否相同

   思路：先根遍历

   首先判断两个二叉树的根节点是否相同，如果不同，直接返回False;如果根节点相同，再判断左子树是否相同，如果不同，则返回False;如果左子树相同，则继续判断右子树是否相同，如果相同则返回True,反之，返回False

   # 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: TreeNode, q: TreeNode) -> bool:
           
           if not p and not q:
               return True
           if not p or not q:
               return False 
           if p.val != q.val:
               return False           
           return self.isSameTree(p.left, q.left) and self.isSameTree(p.right, q.right)
   

2. 对称二叉树

   思路：先根遍历，基本思路同上题目

   # 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: TreeNode) -> bool:
           def helper(n1, n2):
               if not n1 and not n2:
                   return True 
               if not n1 or not n2:
                   return False 
               if n1.val !=n2.val:
                   return False
               return  helper(n1.left, n2.right) and helper(n1.right, n2.left)
           return helper(root,root)
   

3. 二叉树的最大深度

   思路：后根遍历；

   当节点为空时，是一个空树，返回0；反之，则先遍历左子树的最大深度，然后计算右子树的最大深度，两棵树子树深度的最大值，就是整个树的最大深度

   # Definition for a binary tree node.
   # class TreeNode:
   #     def __init__(self, x):
   #         self.val = x
   #         self.left = None
   #         self.right = None
   
   class Solution:
       def maxDepth(self, root: TreeNode) -> int:
           if not root:
               return 0
           return max(self.maxDepth(root.left), self.maxDepth(root.right))+1
   

   4. 判断平衡二叉树

      思路：先根遍历；

      首先判断左右子树最大高度差是否小于等于1，如果不是，则直接返回False; 反之，继续判断左右子树是否分别是平衡二叉树

      # Definition for a binary tree node.
      # class TreeNode:
      #     def __init__(self, x):
      #         self.val = x
      #         self.left = None
      #         self.right = None
      
      class Solution:   
          def height(self, root):        
              if not root:
                  return 0
              return max(self.height(root.left), self.height(root.right))+1
      
          def helper(self, root):
              if not root:
                  return True 
              if abs(self.height(root.left)-self.height(root.right))>1:
                  return False
              return self.helper(root.left) and self.helper(root.right)
      
          def isBalanced(self, root: TreeNode) -> bool:
              return self.helper(root)
      

   5. 二叉树的最小深度（从根节点到最近的叶子结点的路径长度）

      思路：后根遍历；

      当根节点为空时，返回0

      首先计算左子树的最小深度，然后计算右子树的最小深度，根节点的最小深度是左右子树最小深度的最小值；

      需要注意的是，当左子树或者右子树为空时，根节点的最小深度不应该为0，因此对这两种情况要单独判断

      # Definition for a binary tree node.
      # class TreeNode:
      #     def __init__(self, x):
      #         self.val = x
      #         self.left = None
      #         self.right = None
      
      class Solution:
          def minDepth(self, root: TreeNode) -> int:
              if not root:
                  return 0
              if not root.left and root.right:
                  return 1+self.minDepth(root.right)
              if not root.right and root.left:
                  return 1+self.minDepth(root.left)
              return 1+min(self.minDepth(root.left), self.minDepth(root.right))