代码随想录Day13| 110.平衡二叉树 257. 二叉树的所有路径 404.左叶子之和 222.完全二叉树的节点个数

import java.util.ArrayList;
import java.util.List;
import java.util.SimpleTimeZone;

public class Day13 {
    private class TreeNode{
        int val;
        TreeNode left;
        TreeNode right;

        public TreeNode(int val) {
            this.val = val;
        }

        public TreeNode(int val, TreeNode left, TreeNode right) {
            this.val = val;
            this.left = left;
            this.right = right;
        }
    }
    //给定一个二叉树，判断它是否是
    //平衡二叉树
    //平衡二叉树 是指该树所有节点的左右子树的深度相差不超过 1。
    public boolean isBalanced(TreeNode root) {
        return getHeight(root)!=-1;
    }
    public int getHeight(TreeNode root){
        if(root==null)
            return 0;
        int leftDepth=getHeight(root.left);//左 右 中顺序遍历底层有问题直接返回
        int rightDepth=getHeight(root.right);
        if(leftDepth==-1||rightDepth==-1)
            return -1;
        if(Math.abs(leftDepth-rightDepth)>1)
            return -1;
        return 1+Math.max(leftDepth,rightDepth);//高度按最大子树高度计算
    }
    //给你一个二叉树的根节点 root ，按 任意顺序 ，返回所有从根节点到叶子节点的路径。
    //
    //叶子节点 是指没有子节点的节点
    public List<String> binaryTreePaths(TreeNode root) {
        List<String> res=new ArrayList<>();
        if(root==null)
            return res;
        List<Integer> paths=new ArrayList<>();
        traversal(root,res,paths);
        return res;
    }
    public void traversal(TreeNode root,List<String> res,List<Integer> paths){
        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.getLast());//最后一个路径
            res.add(sb.toString());
            return;
        }
        if(root.left!=null){
            traversal(root.left,res,paths);
            paths.removeLast();//回溯
        }
        if(root.right!=null){
            traversal(root.right,res,paths);
            paths.removeLast();
        }
    }
    //给定二叉树的根节点 root ，返回所有左叶子之和。
    public int sumOfLeftLeaves(TreeNode root) {
        if (root == null) return 0;
        int leftValue = sumOfLeftLeaves(root.left);    // 左
        int rightValue = sumOfLeftLeaves(root.right);  // 右
        if (root.left != null && root.left.left == null && root.left.right == null) {
            leftValue = root.left.val;
        }
        int sum =leftValue + rightValue;  // 中
        return sum;
    }
    //给你一棵 完全二叉树 的根节点 root ，求出该树的节点个数。
    //完全二叉树 的定义如下：在完全二叉树中，除了最底层节点可能没填满外，其余每层节点数都达到最大值，
    // 并且最下面一层的节点都集中在该层最左边的若干位置。若最底层为第 h 层，则该层包含 1~ 2h 个节点。
    public int countNodes(TreeNode root) {
        if(root==null)
            return 0;
        int left=countNodes(root.left);
        int right=countNodes(root.right);
        return left+right+1;
    }
    public int countNodes2(TreeNode root) {//完全满二叉树可以直接计算节点数量2^n-1
        //通过判断是否为完全满二叉树来计算数量
        //完全二叉树向下遍历肯定是完全满二叉树
        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;//左移2位
        int leftnum=countNodes2(root.left);//左子树个数返回
        int rightnum=countNodes2(root.right);//右子树个数返回
        return leftnum+rightnum+1;//最后加上根节点
    }
    }