leetcode刷穿二叉树（二）

这里有leetcode题集分类整理！！！

专辑完结，欢迎查看本系列文章：
leetcode刷穿二叉树（一）
leetcode刷穿二叉树（二）
leetcode刷穿二叉树（三）
leetcode刷穿二叉树（四）
leetcode刷穿二叉树（五）
leetcode刷穿二叉树（六）
建议收藏～

• leetcode 222. 完全二叉树的节点个数
• leetcode 110. 平衡二叉树
• leetcode 257. 二叉树的所有路径
• leetcode 100. 相同的树
• leetcode 404. 左叶子之和

1、完全二叉树的节点个数
题目难度：中等
题目描述：

解题思路：

采用迭代的方式，每次访问如果不是空节点结果 + 1；

class Solution {
    public int countNodes(TreeNode root) {
        return root == null? 0 : countNodes(root.left) + countNodes(root.right) + 1;
    }
}

2、 平衡二叉树
题目难度：简单
题目描述：


解题思路：

自顶向下递归比较每个节点的左右子树是否满足平衡二叉树的条件。
定义计算高度的函数
由于每个节点都有被重复利用，因此时间复杂度为 n2

class Solution {
    public boolean isBalanced(TreeNode root) {
        if (root == null) return true;
        return Math.abs(calcHeight(root.left) - calcHeight(root.right)) <= 1 && isBalanced(root.left) && isBalanced(root.right);
    }

    public int calcHeight(TreeNode node) {
        return node == null ? 0 : 1 + Math.max(calcHeight(node.left), calcHeight(node.right));
    }
}
}

解题思路二：

采用自底向上递归：每个节点只会被利用一次 时间复杂度 n2；
采用后序遍历实现自底向上的思想，代码如下：

class Solution {
    public boolean isBalanced(TreeNode root) {
        return calcHeight(root) >= 0;
    }

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

3、二叉树的所有路径
题目难度：简单
题目描述：

解题思路：

第一反应就是dfs

• 遇到叶子节点即将string添加到结果集返回
• 如果是非叶子节点，就递归左右节点，将->和 root.val 拼接string面。
  这里我们一开始尝试了使用StringBuffer 发现结果一直有上一条路径的拼接，看了官解写法才发现， 应该在每次递归的时候都重新定义一个StringBuffer

class Solution {
    private List<String> res = new ArrayList<>();
    public List<String> binaryTreePaths(TreeNode root) {
        StringBuffer sb = new StringBuffer();
        String s = "";
        if (root == null) return res;
        // sb.append(root.val);
        s += root.val;
        if (root.left != null) dfs(root.left, s);
        if (root.right != null) dfs(root.right, s);
        if (root.left == null && root.right == null) {
            res.add(s);
        }
        return res;
    }

    public void dfs(TreeNode root, String s) {
        // sb.append("->");
        // sb.append(root.val);
        s += "->";
        s += root.val;
        if (root.left == null && root.right == null) {
            // res.add(sb.toString());
            res.add(s);
            // sb = new StringBuffer();
            return;
        }
        if (root.left != null) dfs(root.left, s);
        if (root.right != null) dfs(root.right, s);
    }
}

官方写法：

class Solution {
    public List<String> binaryTreePaths(TreeNode root) {
        List<String> paths = new ArrayList<String>();
        constructPaths(root, "", paths);
        return paths;
    }

    public void constructPaths(TreeNode root, String path, List<String> paths) {
        if (root != null) {
            StringBuffer pathSB = new StringBuffer(path);
            pathSB.append(Integer.toString(root.val));
            if (root.left == null && root.right == null) {  // 当前节点是叶子节点
                paths.add(pathSB.toString());  // 把路径加入到答案中
            } else {
                pathSB.append("->");  // 当前节点不是叶子节点，继续递归遍历
                constructPaths(root.left, pathSB.toString(), paths);
                constructPaths(root.right, pathSB.toString(), paths);
            }
        }
    }
}

作者：LeetCode-Solution
链接：https://leetcode-cn.com/problems/binary-tree-paths/solution/er-cha-shu-de-suo-you-lu-jing-by-leetcode-solution/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

bfs写法：

class Solution {
    public List<String> binaryTreePaths(TreeNode root) {
        List<String> paths = new ArrayList<String>();
        if (root == null) {
            return paths;
        }
        Queue<TreeNode> nodeQueue = new LinkedList<TreeNode>();
        Queue<String> pathQueue = new LinkedList<String>();

        nodeQueue.offer(root);
        pathQueue.offer(Integer.toString(root.val));

        while (!nodeQueue.isEmpty()) {
            TreeNode node = nodeQueue.poll(); 
            String path = pathQueue.poll();

            if (node.left == null && node.right == null) {
                paths.add(path);
            } else {
                if (node.left != null) {
                    nodeQueue.offer(node.left);
                    pathQueue.offer(new StringBuffer(path).append("->").append(node.left.val).toString());
                }

                if (node.right != null) {
                    nodeQueue.offer(node.right);
                    pathQueue.offer(new StringBuffer(path).append("->").append(node.right.val).toString());
                }
            }
        }
        return paths;
    }
}

作者：LeetCode-Solution
链接：https://leetcode-cn.com/problems/binary-tree-paths/solution/er-cha-shu-de-suo-you-lu-jing-by-leetcode-solution/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

4、相同的树
题目难度：简单
题目描述：


解题思路：

递归比较每个节点都左右节点是否是相同
递归终止条件：

• 左右节点都为空 返回true
• 左右节点不都为空 返回false
• 左右节点都不为空 比较节点的值，并比较左右节点是否相同

class Solution {
    public boolean isSameTree(TreeNode p, TreeNode q) {
        if (p == null && q == null) return true;
        if (p == null || q == null) return false;
        return p.val == q.val && isSameTree(p.left, q.left) && isSameTree(p.right, q.right);
    }
}

5、左叶子之和
题目难度：简单
题目描述：

解题思路：

每次递归计算左右节点都叶子节点值
如果 左孩子是叶子节点，就将值记录

class Solution {
    public int sumOfLeftLeaves(TreeNode root) {
        if (root == null) return 0;
        return calcVal(root.left) + sumOfLeftLeaves(root.left) + sumOfLeftLeaves(root.right);
    }

    public int calcVal(TreeNode root) {
        if (root == null) return 0;
        if (root.left == null && root.right == null) return root.val;
        return 0;
    }
}

专辑完结，欢迎查看本系列文章：
leetcode刷穿二叉树（一）
leetcode刷穿二叉树（二）
leetcode刷穿二叉树（三）
leetcode刷穿二叉树（四）
leetcode刷穿二叉树（五）
leetcode刷穿二叉树（六）
原创不易，三连支持一下喔～