1. 自顶向下

递归的自顶向下就是先进行操作，再调用自己进行递归

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

  1. /**
  2.  * Definition for a binary tree node.
  3.  * type TreeNode struct {
  4.  *     Val int
  5.  *     Left *TreeNode
  6.  *     Right *TreeNode
  7.  * }
  8.  */
  9. func isSymmetric(root *TreeNode) bool{
  10.     return helper(root,root)
  11. }
  12. func helper(l,r *TreeNode) bool{
  13.     if l==nil && r==nil{
  14.         return true
  15.     }
  16.     if l==nil || r==nil{
  17.         return false
  18.     }
  19.     return l.Val==r.Val && helper(l.Left,r.Right) && helper(l.Right,r.Left)
  20. }

这里就是先判断两个节点的值是否相等，再调用自己传两个节点进去判断是否相等进行递归。
这就是递归的自顶向下，从根节点开始判断，延续到子树。

2. 自底向上

递归的自底向上就是先调用自己进行递归，再进行操作

求二叉树的深度

  1. /**
  2.  * Definition for a binary tree node.
  3.  * type TreeNode struct {
  4.  *     Val int
  5.  *     Left *TreeNode
  6.  *     Right *TreeNode
  7.  * }
  8.  */
  9. func maxDepth(root *TreeNode) int {
  10.     if root ==nil{
  11.         return 0
  12.     }
  13.     left := maxDepth(root.Left)
  14.     rigth := maxDepth(root.Right)
  15.     if left >= rigth{
  16.         return left+1
  17.     }else{
  18.         return rigth+1
  19.     }
  20. }

这里就是先调用自己进行递归，得到自己的左右子树深度，再判断左右子树的深度。
这就是递归的自底向上，先摸进去到底部，再挖上来。