代码随想录day15-优快云博客

第六章二叉树part03

迭代法，大家可以直接过，二刷有精力的时候再去掌握迭代法。

110.平衡二叉树（优先掌握递归）

再一次涉及到，什么是高度，什么是深度，可以巩固一下。

题目链接/文章讲解/视频讲解：https://programmercarl.com/0110.%E5%B9%B3%E8%A1%A1%E4%BA%8C%E5%8F%89%E6%A0%91.html

平衡二叉树就是，任何一个节点的左右子树高度差小于等于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) {
        return getHeight(root) >= 0 ? true : false;

    }
    public int getHeight(TreeNode root) {
        if (root == null) return 0;
        int leftHeight = getHeight(root.left);
        if (leftHeight == -1) return -1;
        int rightHeight = getHeight(root.right);
        if (rightHeight == -1) return -1;
        if (Math.abs(leftHeight - rightHeight) > 1) return -1;
        return Math.max(leftHeight, rightHeight) + 1;

    }
}

注意需要在接收到左右子树的高度时，需要先判断一下是否分别已经不是平衡二叉树了，不是的话直接返回-1.

257. 二叉树的所有路径（优先掌握递归）

这是大家第一次接触到回溯的过程，我在视频里重点讲解了本题为什么要有回溯，已经回溯的过程。

如果对回溯似懂非懂，没关系，可以先有个印象。

题目链接/文章讲解/视频讲解：https://programmercarl.com/0257.%E4%BA%8C%E5%8F%89%E6%A0%91%E7%9A%84%E6%89%80%E6%9C%89%E8%B7%AF%E5%BE%84.html

前序遍历，到达叶子节点其实也就是一条路径完成，需要返回路径，

/**
 * 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<Integer> path = new ArrayList<>();
        List<String> res = new ArrayList<>();
        traversal(root, path, res);
        return res;
    }
    public void traversal(TreeNode root, List<Integer> path, List<String> res){
        path.add(root.val);
        if (root.left == null && root.right == null) {
            StringBuilder sb = new StringBuilder();
            for (int i = 0; i < path.size() - 1; i++) {//之所以是是-1，是因为最后一个节点单独添加
                sb.append(path.get(i)).append("->");//注意这里的append顺序，先加节点值，再append加上一个符号
            }
            sb.append(path.get(path.size()-1));
            res.add(sb.toString());
        }
        if (root.left != null) {
            traversal(root.left, path, res);
            path.remove(path.size() - 1);//注意这里一定是最后一个元素，因为已经到达叶子节点了，需要进行回溯
        }
        if (root.right != null) {
            traversal(root.right, path, res);
            path.remove(path.size() - 1);
        }
    }
}

404.左叶子之和（优先掌握递归）

其实本题有点文字游戏，搞清楚什么是左叶子，剩下的就是二叉树的基本操作。

题目链接/文章讲解/视频讲解：https://programmercarl.com/0404.%E5%B7%A6%E5%8F%B6%E5%AD%90%E4%B9%8B%E5%92%8C.html

这里看了视频之后，发现自己在理解左叶子有问题，左叶子我自己理解的是，左节点，但是没有注意到叶子，其实是叶子节点中的左节点才对。然后因为是对左叶子进行操作，所以这里遍历到叶子节点的上一层就需要停止了，然后需要去判断一个节点的左孩子是否为叶子节点，这样去操作。然后收集左右子树的左叶子之和，在中间节点上进行相加这样的操作，所以采用后序遍历

没太理解清楚这个地方

/**
 * 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 midnum = leftnum + rightnum;
        return midnum;


    }
}

222.完全二叉树的节点个数（优先掌握递归）

需要了解，普通二叉树怎么求，完全二叉树又怎么求

题目链接/文章讲解/视频讲解：https://programmercarl.com/0222.%E5%AE%8C%E5%85%A8%E4%BA%8C%E5%8F%89%E6%A0%91%E7%9A%84%E8%8A%82%E7%82%B9%E4%B8%AA%E6%95%B0.html

普通二叉树的递归方式，还是后序遍历的方法，然后就是一个计数这样的。然后，利用满二叉树的特点的话，就是遍历顺序和普通的没有什么区别，就是计算出左右子树的数量再相加，但是这里在计算左右子树的数量的时候，需要加一点判断条件和处理方法，如果是满二叉树，就可以直接计算出结果而不需要遍历

/**
 * 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; //注意这里的左移符号需要加上括号，计算顺序的问题
        return countNodes(root.left) + countNodes(root.right) + 1;//注意这里是左右中的顺序，先计算左子树的节点数，最后相加还得加上本身节点的1
    }
}