leetcode刷题day15|二叉树Part03（以递归方法为主：110.平衡二叉树、257. 二叉树的所有路径、404.左叶子之和、 222.完全二叉树的节点个数）

110.平衡二叉树

思路：后序遍历递归求左右两棵子树的高度差。1、传入参数：当前树的根节点，如果左右子树高度差小于等于1，返回当前节点为根的树的高度差；否则返回-1，既不满足条件。2、终止条件：如果节点为空，返回0，最底层元素高度为0。3、递归逻辑：递归左子树，递归右子树，左右子树之差大于1返回-1，否则返回该节点为根的树的高度。
代码：

class Solution {
    public boolean isBalanced(TreeNode root) {
        return getDepth(root)!=-1;
    }
    public int getDepth(TreeNode root){
        if(root==null) return 0;
        int leftDepth=getDepth(root.left);
        if(leftDepth==-1) return -1;
        int rightDepth=getDepth(root.right);
        if(rightDepth==-1) return -1;
        return Math.abs(leftDepth-rightDepth)>1?-1:Math.max(leftDepth,rightDepth)+1;
    }
}

257. 二叉树的所有路径

思路：该题的一个关键思路是递归和回溯。使用前序遍历递归，依次遍历节点元素放入list容器中，知道叶子节点，对当前路径进行存储，在回溯回去，将走过路径的节点元素从list容器中移除。
1、传入参数：根节点，存放节点的list，存放路径的list，无返回值。
2、终止条件：当前节点的左右孩子均为空即当前节点为叶子节点。此时将节点list中的元素转为字符串。并存入路径list。
3、递归逻辑：当节点的左孩子不为空时，递归左孩子；右孩子不为空时递归右孩子。
代码：

class Solution {
    public List<String> binaryTreePaths(TreeNode root) {
        List<String> result =new ArrayList<>();
        if(root==null) return result;
        List<Integer> path=new ArrayList<>();
        traversal(root,result,path);
        return result;
    }
    public void traversal(TreeNode root, List result,List path){
        path.add(root.val);
        if(root.left==null && root.right==null){
            StringBuilder sb=new StringBuilder();
            for(int i=0;i<path.size()-1;i++){
                sb.append(path.get(i)).append("->");
            }
            sb.append(path.get(path.size()-1));
            result.add(sb.toString());
        }
        if(root.left!=null){
            traversal(root.left,result,path);
            path.remove(path.size()-1);
        }
        if(root.right!=null){
            traversal(root.right,result,path);
            path.remove(path.size()-1);
        }
    }
}

404.左叶子之和

思路：首先需要判断左叶子，当节点c的左节点a的左孩子和右孩子均为空时，节点a为左叶子节点，此时加上该节点的值。采用后序递归遍历。
1、传入参数：传入根节点，返回叶子节点的值，返回值为int类型。采用原函数即可。
2、终止条件：当节点为null时返回0。
3、递归逻辑：调用递归函数计算左子树的左节叶子之和，调用递归函数计算右子树的左叶子节点之和。定义中间节点的左叶子节点之和为0。判断当前节点的左节点是否满足叶子节点条件，如果满足，中间节点的左叶子节点之和为该左叶子节点的值。最后返回左右中三个节点的左叶子节点之和。
代码如下：

class Solution {
    public int sumOfLeftLeaves(TreeNode root) {
        if(root==null) return 0;
        //左
        int leftValue=0;
        if(root.left!=null) {leftValue=sumOfLeftLeaves(root.left);}
        //右
        int rightValue=0;
        if(root.right!=null) {rightValue=sumOfLeftLeaves(root.right);}
        //中
        int midValue=0;
        if(root.left!=null && root.left.left==null && root.left.right==null){
            midValue=root.left.val;
        }
        int sum=leftValue+midValue+rightValue;
        return sum;
    }
}

222.完全二叉树的节点个数

思路：如果是任意二叉树，直接递归（递归计算左右子树节点的个数和）或者迭代遍历（在遍历过程记录节点个数）即可。
完全二叉树，前h-1层都可以用公式计算。最后一层的数量不定。那么如果子树是满二叉树，可以直接用公式计算，如果不是满二叉树则继续递归。如何判断子树是否为满二叉树？如果左右子树的深度相同，则为满二叉树。
任意二叉树递归解法：

class Solution {
    public int countNodes(TreeNode root) {
        if(root==null) return 0;
        return countNodes(root.left)+countNodes(root.right)+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 int countNodes(TreeNode root) {
        if(root==null) return 0;
        TreeNode left=root.left;
        TreeNode right=root.right;
        int leftDepth=0,rightDepth=0;
        while(left!=null){
            left=left.left;
            leftDepth++;
        }
        while(right!=null){
            right=right.right;
            rightDepth++;
        }
        if(leftDepth==rightDepth){
            return (2 <<leftDepth)-1;//位运算，左移，当leftDepth为1时相当于2*2^1
        }
        return countNodes(root.left)+countNodes(root.right)+1;

    }
}