day4

1、110 平衡二叉树

1. 递归法

   求深度适合用前序遍历，而求高度适合用后序遍历。

   class Solution {
       boolean flag = false;
   
       public boolean isBalanced(TreeNode root) {
           int height = getHeight(root);
           return height!=-1;
       }
   
       //返回以该节点为根节点的二叉树的高度，如果不是平衡二叉树，则返回-1
       public int getHeight(TreeNode node) {
           if(node == null) {
               return 0;
           }
   
           int leftHeight = getHeight(node.left);
           if(leftHeight == -1) {
               return -1;
           }
   
           int rightHeight = getHeight(node.right);
           if(rightHeight == -1) {
               return -1;
           }
   
           int height = Math.abs(leftHeight-rightHeight)>1 ? -1 : Math.max(leftHeight, rightHeight) + 1;
           return height;
       }
   }
   

2、257 二叉树的所有路径

1. 递归法

   class Solution {
       public List<String> binaryTreePaths(TreeNode root) {
           List<String> res = new ArrayList<>();
           backTracking(root, res, "");
           return res;
       }
   
       public void backTracking(TreeNode node, List<String> res, String path) {
           path += String.valueOf(node.val);
   
           if(node.left==null && node.right==null) {
               res.add(path);
               return;
           }
   
           if(node.left != null) {
               backTracking(node.left, res, path+"->");
           }
           if(node.right != null) {
               backTracking(node.right, res, path+"->");
           }
       }
   }
   

3、404 左叶子之和

1. 递归法

2. 递归的遍历顺序为后序遍历（左右中），是因为要通过递归函数的返回值来累加求取左叶子数值之和。

   1. 确定递归函数的参数和返回值
      • 判断一个树的左叶子节点之和，那么一定要传入树的根节点，递归函数的返回值为数值之和，所以为int ==> 使用题目中给出的函数就可以了。
   2. 确定终止条件
      1. 如果遍历到空节点，那么左叶子值一定是0
      2. 只有当前遍历的节点是父节点，才能判断其子节点是不是左叶子。 所以如果当前遍历的节点是叶子节点，那其左叶子也必定是0
   3. 确定单层递归的逻辑
      • 当遇到左叶子节点的时候，记录数值，然后通过递归求取左子树左叶子之和，和 右子树左叶子之和，相加便是整个树的左叶子之和。

   class Solution {
       public int sumOfLeftLeaves(TreeNode root) {
           if(root == null){
               return 0;
           }
           //可不写
           if(root.left == null && root.right == null){//root为叶子节点
               return 0;
           }
   
           int leftValue = sumOfLeftLeaves(root.left);//左，左子树的左叶子节点之和
           if(root.left != null && root.left.left == null && root.left.right == null){ //左子树为左叶子节点
               leftValue = root.left.val;
           }
   
           int rightVal = sumOfLeftLeaves(root.right);//右，右子树的左叶子节点之和
   
           int sum = leftValue + rightVal;//中，左子树的左叶子节点之和 + 右子树的左叶子节点之和
           return sum;
       }
   }
   

   class Solution {
       public int sumOfLeftLeaves(TreeNode root) {
           if(root == null) {
               return 0;
           }  
   
           int leftValue = 0;
           if(root.left!=null && root.left.left==null && root.left.right==null) {
               leftValue = root.left.val;
           }
   
           return leftValue+sumOfLeftLeaves(root.left)+sumOfLeftLeaves(root.right);
       }
   }
   

3. 迭代法

   class Solution {
       public int sumOfLeftLeaves(TreeNode root) {
           int sum = 0;
           Deque<TreeNode> queue = new ArrayDeque<>();
   
           if(root != null) {
               queue.offerLast(root);
           }
   
           while(!queue.isEmpty()) {
               int size = queue.size();
               for(int i=0; i<size; i++) {
                   TreeNode node = queue.pollFirst();
                   if(node.left!= null) {
                       queue.offerLast(node.left);
                       if(node.left.left == null && node.left.right == null) {
                           sum += node.left.val;
                       }
                   }
                   if(node.right!= null) {
                       queue.offerLast(node.right);
                   }
               }
           }
   
           return sum;
       }
   }