day 17 110.平衡二叉树｜257. 二叉树的所有路径｜404.左叶子之和

平衡二叉树

思路：需要抓住平衡二叉树的特点，左子树和右子树的高度差不能超过1，当我们看到高度的时候就应该会想到使用后序遍历来遍历二叉树，采用“左右中”的遍历方式，将子树的结果返回给父亲节点，最终返回给根节点。

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    public boolean isBalanced(TreeNode root) {
        int high = getHigh(root);
        if(high == -1){
            return false;
        }else{
            return true;
        }
    }

    //需要比较每个节点的左右子树的高度差 可以采用后续遍历 “左右中”
    public int getHigh(TreeNode root){
        if(root == null){
            return 0;
        }
        int left = getHigh(root.left);
        if(left == -1){
            return -1;
        }
        int right = getHigh(root.right);
        if(right == -1){
            return -1;
        }
        //左子树和右子树的高度差超过1 不平衡了
        if(Math.abs(left-right) > 1){
            return -1;
        }
        //返回二叉树的高度
        return 1+Math.max(left,right);
    }
}

总结：需要把握住平衡二叉树的特点，使用后序遍历去遍历二叉树，逻辑不是很复杂，多琢磨。

---

257. 二叉树的所有路径

思路：因为需要从根节点一直到叶子结点的路径，所以这一题可以采用前序遍历，从上网下遍历并且保存我们所需要的结果。

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    public List<String> binaryTreePaths(TreeNode root) {
        List<String> res = new ArrayList<>();
        if(root == null){
            return res;
        }
        List<Integer> paths = new ArrayList<>();
        treaval(root,paths,res);
        return res;
    }

    //适用前序遍历来遍历二叉树，因为要从根节点遍历到叶子结点，从上往下遍历 “中左右”
    private void treaval(TreeNode root,List<Integer> paths,List<String> res){
        //加入叶子结点
        paths.add(root.val);
        //确认终止条件
        if(root.left == null && root.right == null){
            StringBuilder sb = new StringBuilder();
            for(int i = 0 ; i< paths.size()-1;i++){
                sb.append(paths.get(i)).append("->");
            }
            sb.append(paths.get(paths.size()-1));
            res.add(sb.toString());
            return;
        }
        if(root.left != null){
            treaval(root.left,paths,res);
            paths.remove(paths.size()-1); //回溯
        }
        if(root.right != null){
            treaval(root.right,paths,res);
            paths.remove(paths.size()-1); //回溯
        }
    }
}

总结：注意 我们在保存叶子结点一定要在终止条件之前，否则叶子结点就没有加入到paths中，终止条件中就是简单的字符串拼接，没什么好说的，重要的就是在遍历左子树和右子树的时候我们需要回溯，因为遍历完一条路径后我们需要重新返回到根节点找到下一条新的路径。

---

404.左叶子之和

思路：我们需要找到左叶子，就必须要知道叶子结点的父亲节点，不然我们只知道他是叶子结点并不知道他是左节点还是右节点，保存左子树的左叶子结点和右子树的左叶子结点然后累加就可以得出结果。遍历顺序的话我们可以采用后续遍历，因为我们需要将保存的结果最终返回给根节点.

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    public int sumOfLeftLeaves(TreeNode root) {
        if(root == null){
            return 0;
        }
        //遇到叶子结点也直接返回
        if(root.left == null && root.right == null){
            return 0;
        }
        //采用后序遍历，将结果返回给父亲节点
        int leftNum = sumOfLeftLeaves(root.left);
        //遍历到叶子结点的父亲节点时 我们才能知道叶子结点是否为左叶子
        if(root.left != null && root.left.left==null && root.left.right == null){
            leftNum = root.left.val;
        }
        int rightNum = sumOfLeftLeaves(root.right);
        int sum = leftNum + rightNum;
        return sum;
    }
}

总结：这一题的逻辑不是很复杂，重点就是如何判断该节点是否为左叶子结点（root.left != null && root.left.left==null && root.left.right == null），这个判断需要想清楚，然后就是遍历的顺序使用后续遍历。