夸父追日：第六章 二叉树 part03

今日收获（优先递归）：平衡二叉树，二叉树的所有路径，左叶子之和，完全二叉树的节点个数

1. 平衡二叉树-后序遍历

题目链接：110. - 力扣（LeetCode）

思路：求本节点的高度时，额外判断左右子树是否不平衡，左右子树的高度差是否大于1

方法：

class Solution {
    public boolean isBalanced(TreeNode root) {
        // 递归
        return getHeight(root)!=-1;
    }

    // 求节点高度并判断左右子树高度差
    public int getHeight(TreeNode node){
        if (node==null){
            return 0;
        }

        int leftHeight=getHeight(node.left);
        int rightHeight=getHeight(node.right);
        

        if (leftHeight==-1||rightHeight==-1){
            return -1;
        }

        if ((Math.abs(leftHeight-rightHeight))>1){
            return -1;
        }

        return 1+Math.max(leftHeight,rightHeight);
    }
}

2. 二叉树的所有路径-前序遍历

题目链接：257. - 力扣（LeetCode）

思路：利用数组记录一条路径上的数值。如果遇到了叶子节点，就将路径数组转化为字符串，如果不是叶子节点，继续向左右子树递归。注意左右子树递归结束后要删除左右节点的值，相当于路径又回到了中间节点上。

方法：

class Solution {
    List<String> result=new ArrayList<>();  // 所有路径的字符串
    List<Integer> path=new ArrayList<>();  // 一天路径的数值

    public List<String> binaryTreePaths(TreeNode root) {
        travel(root);
        return result;
    }

    public void travel(TreeNode node){
        path.add(node.val);
        if (node.left==null&&node.right==null){  // 叶子节点，收获一条路径
            StringBuilder sb=new StringBuilder();
            for (int i=0;i<path.size()-1;i++){
                sb.append(path.get(i)+"->");
            }
            sb.append(path.get(path.size()-1));
            result.add(sb.toString());
            return;
        }

        // 不是叶子节点，继续往下
        if (node.left!=null){
            travel(node.left);
            path.remove(path.size()-1);  // 回溯，从左节点返回中间节点
        }

        if (node.right!=null){
            travel(node.right);
            path.remove(path.size()-1);  // 回溯，从右节点返回中间节点
        }
    } 
}

总结：第一次遇到回溯，有点像深度优先遍历 

3. 左叶子之和-后序遍历

题目链接：404. - 力扣（LeetCode）

思路：当前节点的左叶子和=当前节点的左叶子值+当前节点左孩子的左叶子和+当前节点右孩子的左叶子和。

方法：

class Solution {
    public int sumOfLeftLeaves(TreeNode root) {
        // 后序遍历
        if (root==null){
            return 0;
        }

        // 当前节点的左叶子值
        int mid=0;
        if (root.left!=null&&root.left.left==null&&root.left.right==null){
            mid= root.left.val;
        }

        return mid+sumOfLeftLeaves(root.left)+sumOfLeftLeaves(root.right);
    }
}

总结：递归函数的作用是求节点的左叶子之和，所以需要三部分相加；判断当前节点是否是左叶子只能由其父节点判断。

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

题目链接：222. - 力扣（LeetCode）

思路：当前节点所在树的节点个数 = 左孩子节点数 + 右孩子节点数 + 1

方法：

class Solution {
    public int countNodes(TreeNode root) {
        // 后序遍历
        if (root==null){
            return 0;
        }

        // 左右孩子节点数
        int leftSum=countNodes(root.left);
        int rightSum=countNodes(root.right);
        return leftSum+rightSum+1;
    }
}

5. 遍历方式的选择

如果求路径，需要从上到下遍历，则需要用前序遍历；

如果是判断树是否满足某一种特点或者求和，则利用后序遍历；

二叉搜索树常用中序遍历，通常使用全局指针记录当前遍历节点的上一个节点。