力扣刷题Day15

110.平衡二叉树

题目：力扣

自己的解题思路：

采用的是前序遍历的方法。从根节点开始判断是否左右子树的高度是小于等于1的；之后再判断左子树、右子树。而用于计算二叉树子树的高度的函数是后序遍历。

按照递归的三部曲：

1.确定输入和输出 - 输入：TreeNode root； 输出：boolean值 - 判断二叉树左侧节点&&判断二叉树右侧节点 

2.确定终止条件：空节点- 则返回true。

3.确定递归逻辑：计算左侧节点的高度，计算右侧节点的高度，若左侧节点的高度减去右侧节点高度的绝对值大于0，则返回false，否则返回true。

class Solution {
    public boolean isBalanced(TreeNode root) {
        //终止条件
        if(root == null){
            return true;
        }

        int left = height(root.left);
        int right = height(root.right);

        if(Math.abs(left - right)>1){
            return false;
        }

        //返回值 - boolean
        return isBalanced(root.left) && isBalanced(root.right);
    }

    public int height(TreeNode root){
        if(root == null){
            return 0;
        }

        int left = height(root.left);
        int right = height(root.right);

        int height = Math.max(left, right)+1;

        return height;
    }
}

存在的问题是：效率并不是很高，根节点处需要计算左子树和右子树的高度，等于对整个左子树和右子树进行了遍历；而接着遍历root.left，又需要对左子树根节点的左子树和右子树进行遍历，也就是第二次遍历了左子树 -- 因此整个代码中的重复遍历次数会非常多。

改进：

在进行高度计算的时候，同时判断左右子树的个数是否平衡。 若不平衡直接记为-1。<在计算左右子树的高度中，若遇到-1，则可以直接返回-1>

那么在主方法中直接判断高度是否为-1就可以知道整个树是否为平衡二叉树。

因为计算高度的时候采用的是后序遍历，因此整棵树只需要遍历一次就可以知道结果，效率会更高。

代码实现：

class Solution {
    public boolean isBalanced(TreeNode root) {
       int h = height(root);

       return h != -1;
    }

    public int height(TreeNode root){
        //终止条件
        if(root == null){
            return 0;
        }

        int left = height(root.left);//左
        if(left == -1) return -1;
        int right = height(root.right);//右
        if(right == -1) return -1;

        int height;//中间节点
        if(Math.abs(left - right) >1){
            height = -1;
        }else{
            height = Math.max(left, right)+1;
        }

        //输出结果
        return height;
    }
}

参考资料：代码随想录 

257. 二叉树的所有路径 

 题目：力扣

这道题采用的是前序遍历的方法，递归+回溯；

递归三部曲：

1. 确定输入和输出：输入（TreeNode root，List<String> result，String s）= 当前节点，路径储存list，当前遍历路径
2. 确定终止条件：如果节点左右指针都为空 - 将当前路径加入list，返回；
3. 单层循环逻辑：记录节点左边的路径+回溯 && 记录节点右边的路径+回溯；

在实现的时候刚开始是直接用String来储存了数据，出现了两个问题：

• 问题1: 空指针报错
• 问题2:回溯的时候，index出界 

问题1的原因是 没有判断左右指针是否为空直接添加了左右指针的值（即使终止条件是左右指针都为空，但是可能会存在左指针为空或者右指针为空的情况）；

问题2的原因是 回溯的方式不对 - 直接删除了最后三个字符，但是可能存在此时s的length为1的情况，这个时候是只需要删除1个字符就可以。---> 解决问题方式：在开始的时候先记录s的长度，回溯直接截取原来s长度的字符。、

最终代码实现：

class Solution {
    public List<String> binaryTreePaths(TreeNode root) {
        //回溯 - 需要走所有的路径
        List<String> result = new ArrayList<>();
        if(root == null){
            return result;
        }

        dfs(root, result, ""+root.val);//中间节点
        return result;
    }

    public void dfs(TreeNode root, List<String> result, String s){
        //终止条件
        if(root.left == null && root.right == null){
            result.add(s.toString());
            return;
        }

       
        int length = s.length();//记录当前String的长度
        if(root.left != null){//左节点
            dfs(root.left, result, s+"->"+root.left.val);
           s= s.substring(0, length);//回溯
        }

        if(root.right != null){//右节点
            dfs(root.right, result, s+"->"+root.right.val);
             s= s.substring(0, length);//回溯
        }
       
        //返回值 - 没有返回值
        return;
    }
}

也可以用StringBuffer来储存当前路径：<注意StringBuffer的api使用 - 添加和删除>

class Solution {
    public List<String> binaryTreePaths(TreeNode root) {
        //回溯 - 需要走所有的路径
        List<String> result = new ArrayList<>();
        if(root == null){
            return result;
        }
        StringBuilder s = new StringBuilder();
        s.append(root.val);//中间节点
        dfs(root, result, s);
        return result;
    }

    public void dfs(TreeNode root, List<String> result, StringBuilder s){
        //终止条件
        if(root.left == null && root.right == null){
            result.add(s.toString());
            return;
        }

        
        int length = s.length();//当前路径长度
        if(root.left != null){//左节点
            dfs(root.left, result, s.append("->").append(root.left.val));
            s.delete(length, s.length());//回溯
        }

        if(root.right != null){//右节点
            dfs(root.right, result, s.append("->").append(root.right.val));
            s.delete(length, s.length());//回溯
        }
       
        //返回值 - 没有返回值
        return;
    }
}

还可以用ArrayList来储存路径，回溯的时候直接删除最后一个元素，在储存路径的时候将其转化成String。

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();
            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);// 回溯
        }
    }

参考资料：代码随想录 

404.左叶子之和 

 题目：力扣

 可以参考求二叉树最大深度的做法，使用递归来求和。

那么这里可以考虑采用后序遍历。

                中间节点 = 左子树中左叶子之和 + 右子树左叶子之和。

自己实现的递归思路：

1. 确定输入和输出：输入 - TreeNode root；输出 - int sum
2. 确定终止条件：1）若找到左节点 - root的左节点不为空，而root的左节点的左右两个节点都为空---返回 root.left.val；2）节点为空 --- 返回 0；
3. 单层循环逻辑：先遍历左子树，计算左子树的左叶子之和；再遍历右子树，计算右子树的左叶子之和；最后将左右子树左叶子之和相加。

但是结果出现了问题，只有第一个左节点的值。

这是因为将找左节点放到了终止条件中，那么在找到第一个左节点之后，这个方法就结束了，直接返回了第一个左节点的值，不会继续递归。

因此寻找左节点这个步骤不能是在终止条件中，而是在单层递归逻辑中每层都要寻找。

正确的递归思路：

1. 确定输入和输出：输入 - TreeNode root；输出 - int sum
2. 确定终止条件：节点为空 --- 返回 0；
3. 单层循环逻辑：先遍历左子树，若找到左节点 - root的左节点不为空，而root的左节点的左右两个节点都为空--- 更新左子树的值 = 左叶子节点的值<这里不需要用累加的原因是，对于单层来说，左子树的左叶子节点只有一个>；再遍历右子树，计算右子树的左叶子值；最后将左右子树左叶子之和相加。

代码实现：

   public int sumOfLeftLeaves(TreeNode root) {
        //终止条件
        if(root == null){
            return 0;
        }

        //单层递归逻辑
        int left = sumOfLeftLeaves(root.left);
        if(root.left != null && root.left.left == null && root.left.right == null){
            left = root.left.val;
        }
        int right = sumOfLeftLeaves(root.right);

        int sum = left + right;

        //输出
        return sum;
    }

参考资料：代码随想录 

总结：

需要先判断是采用什么遍历方式；采用递归三部曲完成递归思路；递归进行求和的方式是非常常用的，一般配合后序遍历来使用。