上好的刷题Day15

【题目1】给定一个二叉树，判断它是否是高度平衡的二叉树。

思路：通过高度判断相差是都为1，递归时候信息要向上传递，如果有不平衡的就终止

class Solution {
    public boolean isBalanced(TreeNode root) {
        return depth(root) != -1;
    }
    public int depth(TreeNode root){
        if(root == null)
            return 0;
        int l_Depth = depth(root.left);
        if(l_Depth == -1)
            return -1;
        int r_Depth = depth(root.right);
        if(r_Depth == -1)
            return -1;
        if(Math.abs(l_Depth-r_Depth)>1)
            return -1;
        return Math.max(l_Depth,r_Depth) +1;
    }
}

【题目2】递归+回溯

给你一个二叉树的根节点 root ，按 任意顺序 ，返回所有从根节点到叶子节点的路径。

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

迭代法
// 解法2
class Solution {
    /**
     * 迭代法
     */
    public List<String> binaryTreePaths(TreeNode root) {
        List<String> result = new ArrayList<>();
        if (root == null)
            return result;
        Stack<Object> stack = new Stack<>();
        // 节点和路径同时入栈
        stack.push(root);
        stack.push(root.val + "");
        while (!stack.isEmpty()) {
            // 节点和路径同时出栈
            String path = (String) stack.pop();
            TreeNode node = (TreeNode) stack.pop();
            // 若找到叶子节点
            if (node.left == null && node.right == null) {
                result.add(path);
            }
            //右子节点不为空
            if (node.right != null) {
                stack.push(node.right);
                stack.push(path + "->" + node.right.val);
            }
            //左子节点不为空
            if (node.left != null) {
                stack.push(node.left);
                stack.push(path + "->" + node.left.val);
            }
        }
        return result;
    }
}

【题目3】给定二叉树的根节点 root ，返回所有左叶子之和。

思路：传递一个变量，判断是否是左叶子

class Solution {
    public int sumOfLeftLeaves(TreeNode root) {
        return sum(root,false);
    }
    public int sum(TreeNode root, boolean flag){
        if(root == null)
            return 0;   
        if(root.left == null && root.right ==null && flag)
            return root.val; 
        return sum(root.left,true) + sum(root.right,false);   
    }
}

// 在栈里面设置一个标记，标记左节点
class Solution {
    public int sumOfLeftLeaves(TreeNode root) {
        Stack<TreeNode> stack = new Stack<>();
        if(root == null)
            return 0;
        stack.push(root);
        int sum = 0;
        while(!stack.isEmpty()){
            TreeNode p = stack.pop();
            if(p==null){
                p = stack.pop();
                if(p.left == null && p.right == null)
                    sum+= p.val;
            }
            if(p.right != null)
                stack.push(p.right);            
            if(p.left != null){
                stack.push(p.left);
                stack.push(null);
            }          
        }
        return sum;
    }
}

class Solution {
    public int sumOfLeftLeaves(TreeNode root) {
        if (root == null) return 0;
        Stack<TreeNode> stack = new Stack<> ();
        stack.add(root);
        int result = 0;
        while (!stack.isEmpty()) {
            TreeNode node = stack.pop();
            if (node.left != null && node.left.left == null && node.left.right == null) {
                result += node.left.val;
            }
            if (node.right != null) stack.add(node.right);
            if (node.left != null) stack.add(node.left);
        }
        return result;
    }
}

【题目4】！！！

给定一个二叉树的 根节点 root，请找出该二叉树的 最底层 最左边 节点的值。假设二叉树中至少有一个节点。

思路：迭代法，层次遍历方便，找到最后一层层次遍历第一个节点就行

    public int findBottomLeftValue(TreeNode root) {
        Queue<TreeNode> queue = new LinkedList<>();
        queue.offer(root);
        int value = -1;
        while(!queue.isEmpty()){           
            int len = queue.size();
            int Temp_len = len;
            while(len > 0){
                TreeNode p = queue.poll();
                if(len == Temp_len)  // 记录第一个
                    value = p.val;
                if(p.left != null)
                    queue.offer(p.left);
                if(p.right != null)
                    queue.offer(p.right);
                len--;
            }
        }
        return value;
    }

递归法！！！

如果需要遍历整棵树，递归函数就不能有返回值。如果需要遍历某一条固定路线，递归函数就一定要有返回值！

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

参数必须有要遍历的树的根节点，还有就是一个int型的变量用来记录最长深度。 这里就不需要返回值了，所以递归函数的返回类型为void。

本题还需要类里的两个全局变量，maxLen用来记录最大深度，maxleftValue记录最大深度最左节点的数值。

2. 确定终止条件

当遇到叶子节点的时候，就需要统计一下最大的深度了，所以需要遇到叶子节点来更新最大深度。

3. 确定单层递归的逻辑

在找最大深度的时候，递归的过程中依然要使用回溯

// 递归法
class Solution {
    private int Deep = -1;
    private int value = 0;
    public int findBottomLeftValue(TreeNode root) {
        value = root.val;
        findLeftValue(root,0);
        return value;
    }

    private void findLeftValue (TreeNode root,int deep) {
        if (root == null) return;
        if (root.left == null && root.right == null) {
            if (deep > Deep) {
                value = root.val;
                Deep = deep;
            }
        }
        if (root.left != null) findLeftValue(root.left,deep + 1);
        if (root.right != null) findLeftValue(root.right,deep + 1);
    }
}

植树造林​​​​​​​