代码随想录一刷(day17) |110.平衡二叉树|257. 二叉树的所有路径|404.左叶子之和

qq_73918567

已于 2023-11-30 20:32:50 修改

阅读量357

点赞数 10

文章标签：算法数据结构

于 2023-11-30 20:28:53 首次发布

本文链接：https://blog.csdn.net/qq_73918567/article/details/134719089

版权

文章介绍了如何使用后序遍历检查平衡二叉树的高度差，以及通过前序遍历获取二叉树所有路径。还讨论了左叶子之和问题，强调了在递归过程中判断节点属性的重要性。

摘要由CSDN通过智能技术生成

110.平衡二叉树 leetcode链接

思考

平衡二叉树的定义： 任一节点对应的两棵子树的最大高度差为1

看到高度差我们应该确定本题的遍历方法为后序遍历

1.明确递归方法的参数和返回类型

public int height(TreeNode root)

2.确定递归终止条件

if (root == null) {
       return 0;
   }

3.明确单层递归逻辑

int leftHeight = height(root.left);
        if (leftHeight == -1) {
            return -1;
        }
        int rightHeight = height(root.right);
        if (rightHeight == -1) {
            return -1;
        }
        if (Math.abs(leftHeight - rightHeight) > 1) {
            return -1;
        }
        return Math.max(leftHeight, rightHeight) + 1;

代码展示

class Solution {
     public boolean isBalanced(TreeNode root) {
        int height = height(root);
        if (height == -1) {
            return false;
        }
        return true;
    }
    public int height(TreeNode root){
        if (root == null) {
            return 0;
        }
        int leftHeight = height(root.left);
        if (leftHeight == -1) {
            return -1;
        }
        int rightHeight = height(root.right);
        if (rightHeight == -1) {
            return -1;
        }
        if (Math.abs(leftHeight - rightHeight) > 1) {
            return -1;
        }
        return Math.max(leftHeight, rightHeight) + 1;
    }
}
class TreeNode {
    int val;
    TreeNode left;
    TreeNode right;

    public TreeNode() {
    }

    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，计算二叉树高度时使用后序遍历

257. 二叉树的所有路径 leetcode链接

思考

根据题目的要求，要保存每一条从根节点到叶子节点的路径，由此可以确定选择使用前序遍历。

1.明确递归函数参数和返回值：

public void getAllPaths(TreeNode root, List<Integer> paths, List<String> result)

2.明确终止条件：

root.left == null && root.right == null

此时遍历到叶子节点，并且将沿途的节点保存到了paths中。将paths中保存的路径放入到result结果集中，然后向上回溯，直到遇见带有右节点的节点，再向右遍历，最终遍历完二叉树所有路径

3.明确单层递归逻辑

//中
        paths.add(root.val);
        if (root.left == null && root.right == null) {
            StringBuilder stringBuilder = new StringBuilder();
            for (int i = 0; i < paths.size() - 1; i++) {
                stringBuilder.append(paths.get(i) + "->");
            }
            //添加最后一个元素
            stringBuilder.append(paths.get(paths.size() - 1));
            String str = stringBuilder.toString();
            result.add(str);
            return;
        }
        //左
        if (root.left != null) {
            getAllPaths(root.left,paths,result);
            paths.remove(paths.size() - 1);
        }

        //右
        if (root.right != null) {
            getAllPaths(root.right,paths,result);
            paths.remove(paths.size() - 1);
        }

代码展示

class Solution {
 public List<String> binaryTreePaths(TreeNode root) {
        List<String> res = new ArrayList<>();
        List<Integer> paths = new ArrayList<>();
        if (root == null) {
            return res;
        }
        getAllPaths(root,paths,res);
        return res;
    }
    public void getAllPaths(TreeNode root, List<Integer> paths, List<String> result){
        //中
        paths.add(root.val);
        if (root.left == null && root.right == null) {
            StringBuilder stringBuilder = new StringBuilder();
            for (int i = 0; i < paths.size() - 1; i++) {
                stringBuilder.append(paths.get(i) + "->");
            }
            //添加最后一个元素
            stringBuilder.append(paths.get(paths.size() - 1));
            String str = stringBuilder.toString();
            result.add(str);
            return;
        }
        //左
        if (root.left != null) {
            getAllPaths(root.left,paths,result);
            paths.remove(paths.size() - 1);
        }

        //右
        if (root.right != null) {
            getAllPaths(root.right,paths,result);
            paths.remove(paths.size() - 1);
        }
    }
}
class TreeNode {
    int val;
    TreeNode left;
    TreeNode right;

    public TreeNode() {
    }

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

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

总结

本文我们开始初步涉及到了回溯，很多同学过了这道题目，可能都不知道自己其实使用了回溯，回溯和递归都是相伴相生的。 ————《代码思想录》

404.左叶子之和

思路

首先思考，什么是左子叶？即：为其父节点的做孩子的叶子节点。其次，如何记录左子叶的值？注意：不能在遍历到叶子节点时进行记录，因为此时无法判断叶子节点是否为其父节点的左孩子。因此，只能再往上一层进行判断，在其父节点中进行判断。

1.明确递归函数的参数和返回值：

public int sumOfLeftLeaves(TreeNode root)

2明确递归终止条件

        if (root == null) {
            return 0;
        }
        if (root.left == null && root.right == null) {//减少一次循环
            return 0;
        }

3.明确单层递归逻辑

        //左
        int leftValue = sumOfLeftLeaves(root.left);
        if (root.left != null && root.left.left == null && root.left.right == null) {
            leftValue = root.left.val;
        }
        //右
        int rightValue = sumOfLeftLeaves(root.right);
        //中
        return leftValue + rightValue;

代码展示

class Solution {
      public int sumOfLeftLeaves(TreeNode root) {
        if (root == null) {
            return 0;
        }
        if (root.left == null && root.right == null) {//减少一次循环
            return 0;
        }
        //左
        int leftValue = sumOfLeftLeaves(root.left);
        if (root.left != null && root.left.left == null && root.left.right == null) {
            leftValue = root.left.val;
        }
        //右
        int rightValue = sumOfLeftLeaves(root.right);
        //中
        return leftValue + rightValue;
    }
}
class TreeNode {
    int val;
    TreeNode left;
    TreeNode right;

    public TreeNode() {
    }

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

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