代码随想录算法训练营第十七天 |110.平衡二叉树，257.二叉树的所有路径，404.左叶子之和（待补充）

柔情只为你懂 2024-04-23 04:04 54阅读 0赞

### 110.平衡二叉树 ###

1、题目链接：[力扣（LeetCode）官网 - 全球极客挚爱的技术成长平台][LeetCode_ -]

2、文章讲解：[代码随想录][Link 1]

3、题目：

给定一个二叉树，判断它是否是高度平衡的二叉树。

本题中，一棵高度平衡二叉树定义为：一个二叉树每个节点 的左右两个子树的高度差的绝对值不超过1。

示例 1:

给定二叉树 \[3,9,20,null,null,15,7\]

![b5a5c301aa39f3dc77e600a6add0117c.png][]

返回 true 。

示例 2:

给定二叉树 \[1,2,2,3,3,null,null,4,4\]

![78403a161fa26f733df4474109bfbbd7.png][]

返回 false 。

4、视频链接：

[后序遍历求高度，高度判断是否平衡 | LeetCode：110.平衡二叉树\_哔哩哔哩\_bilibili][_ LeetCode_110._bilibili]

5、思路：

class Solution {
        /**
         * 递归法
         */
        public boolean isBalanced(TreeNode root) {
            return getHeight(root) != -1;
        }
    
        private 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;
            }
            // 左右子树高度差大于1，return -1表示已经不是平衡树了
            if (Math.abs(leftHeight - rightHeight) > 1) {
                return -1;
            }
            return Math.max(leftHeight, rightHeight) + 1;
        }
    }

class Solution {
        /**
         * 优化迭代法，针对暴力迭代法的getHeight方法做优化，利用TreeNode.val来保存当前结点的高度，这样就不会有重复遍历
         * 获取高度算法时间复杂度可以降到O(1)，总的时间复杂度降为O(n)。
         * 时间复杂度：O(n)
         */
        public boolean isBalanced(TreeNode root) {
            if (root == null) {
                return true;
            }
            Stack<TreeNode> stack = new Stack<>();
            TreeNode pre = null;
            while (root != null || !stack.isEmpty()) {
                while (root != null) {
                    stack.push(root);
                    root = root.left;
                }
                TreeNode inNode = stack.peek();
                // 右结点为null或已经遍历过
                if (inNode.right == null || inNode.right == pre) {
                    // 输出
                    if (Math.abs(getHeight(inNode.left) - getHeight(inNode.right)) > 1) {
                        return false;
                    }
                    stack.pop();
                    pre = inNode;
                    root = null;// 当前结点下，没有要遍历的结点了
                } else {
                    root = inNode.right;// 右结点还没遍历，遍历右结点
                }
            }
            return true;
        }
    
        /**
         * 求结点的高度
         */
        public int getHeight(TreeNode root) {
            if (root == null) {
                return 0;
            }
            int leftHeight = root.left != null ? root.left.val : 0;
            int rightHeight = root.right != null ? root.right.val : 0;
            int height = Math.max(leftHeight, rightHeight) + 1;
            root.val = height;// 用TreeNode.val来保存当前结点的高度
            return height;
        }
    }

### 257.二叉树的所有路径 ###

1、题目链接：[力扣（LeetCode）官网 - 全球极客挚爱的技术成长平台][LeetCode_ - 1]

2、文章讲解：[代码随想录][Link 2]

3、题目：

给定一个二叉树，返回所有从根节点到叶子节点的路径。

说明: 叶子节点是指没有子节点的节点。

示例:

![c8064e139befed7405678995ae0854aa.png][]

4、视频链接：

[递归中带着回溯，你感受到了没？| LeetCode：257. 二叉树的所有路径\_哔哩哔哩\_bilibili][LeetCode_257. _bilibili]

5、思路：

class Solution {
        /**
         * 递归法
         */
        public List<String> binaryTreePaths(TreeNode root) {
            List<String> res = new ArrayList<>();// 存最终的结果
            if (root == null) {
                return res;
            }
            List<Integer> paths = new ArrayList<>();// 作为结果中的路径
            traversal(root, paths, res);
            return res;
        }
    
        private void traversal(TreeNode root, List<Integer> paths, List<String> res) {
            paths.add(root.val);// 前序遍历，中
            // 遇到叶子结点
            if (root.left == null && root.right == null) {
                // 输出
                StringBuilder sb = new StringBuilder();// 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) { // 左
                traversal(root.left, paths, res);
                paths.remove(paths.size() - 1);// 回溯
            }
            if (root.right != null) { // 右
                traversal(root.right, paths, res);
                paths.remove(paths.size() - 1);// 回溯
            }
        }
    }

class Solution {
        /**
         * 递归法
         */
        List<String> result = new ArrayList<>();
    
        public List<String> binaryTreePaths(TreeNode root) {
            deal(root, "");
            return result;
        }
    
        public void deal(TreeNode node, String s) {
            if (node == null)
                return;
            if (node.left == null && node.right == null) {
                result.add(new StringBuilder(s).append(node.val).toString());
                return;
            }
            String tmp = new StringBuilder(s).append(node.val).append("->").toString();
            deal(node.left, tmp);
            deal(node.right, tmp);
        }
    }

### 404.左叶子 ###

1、题目链接：[力扣（LeetCode）官网 - 全球极客挚爱的技术成长平台][LeetCode_ - 2]

2、文章讲解：[代码随想录][Link 3]

3、题目：

计算给定二叉树的所有左叶子之和。

示例：

![c6394cfc9e99bf2e71b7a9a828f146c3.png][]

4、思路：

class Solution {
        public int sumOfLeftLeaves(TreeNode root) {
            if (root == null) {
                return 0;
            }
            int leftValue = sumOfLeftLeaves(root.left);    // 左
            int 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 = midValue + leftValue + rightValue;  // 中
            return sum;
    
        }
    }

class Solution {
        public int sumOfLeftLeaves(TreeNode root) {
            int sum = 0;
            if (root == null) return 0;
            Queue<TreeNode> queue = new LinkedList<>();
            queue.offer(root);
            while (!queue.isEmpty()) {
                int size = queue.size();
                while (size-- > 0) {
                    TreeNode node = queue.poll();
                    if (node.left != null) { // 左节点不为空
                        queue.offer(node.left);
                        if (node.left.left == null && node.left.right == null) { // 左叶子节点
                            sum += node.left.val;
                        }
                    }
                    if (node.right != null) queue.offer(node.right);
                }
            }
            return sum;
        }
    }

[LeetCode_ -]: https://leetcode.cn/problems/balanced-binary-tree/
[Link 1]: https://programmercarl.com/0110.%E5%B9%B3%E8%A1%A1%E4%BA%8C%E5%8F%89%E6%A0%91.html#%E7%AE%97%E6%B3%95%E5%85%AC%E5%BC%80%E8%AF%BE
[b5a5c301aa39f3dc77e600a6add0117c.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/23/755e2e1a88474be4b23881c8af6a5bcf.png
[78403a161fa26f733df4474109bfbbd7.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/23/967e389a6b434409b93f791881a5d231.png
[_ LeetCode_110._bilibili]: https://www.bilibili.com/video/BV1Ug411S7my
[LeetCode_ - 1]: https://leetcode.cn/problems/binary-tree-paths/
[Link 2]: 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#%E7%AE%97%E6%B3%95%E5%85%AC%E5%BC%80%E8%AF%BE
[c8064e139befed7405678995ae0854aa.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/23/535c8e16e9f947b69425067f6ad97ac2.png
[LeetCode_257. _bilibili]: https://www.bilibili.com/video/BV1ZG411G7Dh
[LeetCode_ - 2]: https://leetcode.cn/problems/sum-of-left-leaves/
[Link 3]: https://programmercarl.com/0404.%E5%B7%A6%E5%8F%B6%E5%AD%90%E4%B9%8B%E5%92%8C.html#%E7%AE%97%E6%B3%95%E5%85%AC%E5%BC%80%E8%AF%BE
[c6394cfc9e99bf2e71b7a9a828f146c3.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/23/4dfda4937b2b4742837dad085643e7ba.png