404. 左叶子之和（简单）—树的遍历、BFS、DFS

最新推荐文章于 2021-04-07 20:43:48 发布

希望不断地学习知识

最新推荐文章于 2021-04-07 20:43:48 发布

阅读量122

点赞数

分类专栏： LeetCode每日一题文章标签：数据结构 leetcode

本文链接：https://blog.csdn.net/qq_38454093/article/details/108686111

版权

LeetCode每日一题专栏收录该内容

40 篇文章 1 订阅

订阅专栏

404. 左叶子之和

关键词：树、树的遍历、广度优先搜索BFS、深度优先搜索DFS

题目要求：

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

示例：

    3
   / \
  9  20
    /  \
   15   7

在这个二叉树中，有两个左叶子，分别是 9 和 15，所以返回 24

题解：

考虑到《数据结构》中学到的树的中序、先序、后序遍历，此题和树的中序遍历有些相似，故而加以改写：

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
class Solution {
    public int sumOfLeftLeaves(TreeNode root) {
        if(root == null){
            return 0;
        }
        else{
            int left = 0;
            int right = 0;
            if(root.right != null){
                right = RightTreeTraversal(root.right);
            }
            if(root.left != null){
                left = LeftTreeTraversal(root.left);
            }
            return left + right;
            }
    }

    public int LeftTreeTraversal(TreeNode root){
        if(root.right == null && root.left == null){
            return root.val;
        }else if(root.right == null){
             return LeftTreeTraversal(root.left);
        }else if(root.left == null){
            return RightTreeTraversal(root.right);
        }else{
            int left = LeftTreeTraversal(root.left);
            int right = RightTreeTraversal(root.right);
            return left + right;
        }
    }

    public int RightTreeTraversal(TreeNode root){
        if(root.right == null && root.left == null){
            return 0;
        }else if(root.right == null){
             return LeftTreeTraversal(root.left);
        }else if(root.left == null){
            return RightTreeTraversal(root.right);
        }else{
            int left = LeftTreeTraversal(root.left);
            int right = RightTreeTraversal(root.right);
            return left + right;
        }
    }
}

得到的结果也还行：
在这里插入图片描述

同样附上官方的答案:

1.深度优先搜索

class Solution {
    public int sumOfLeftLeaves(TreeNode root) {
        return root != null ? dfs(root) : 0;
    }

    public int dfs(TreeNode node) {
        int ans = 0;
        if (node.left != null) {
            ans += isLeafNode(node.left) ? node.left.val : dfs(node.left);
        }
        if (node.right != null && !isLeafNode(node.right)) {
            ans += dfs(node.right);
        }
        return ans;
    }

    public boolean isLeafNode(TreeNode node) {
        return node.left == null && node.right == null;
    }
}

2.广度优先搜索

class Solution {
    public int sumOfLeftLeaves(TreeNode root) {
        if (root == null) {
            return 0;
        }

        Queue<TreeNode> queue = new LinkedList<TreeNode>();
        queue.offer(root);
        int ans = 0;
        while (!queue.isEmpty()) {
            TreeNode node = queue.poll();
            if (node.left != null) {
                if (isLeafNode(node.left)) {
                    ans += node.left.val;
                } else {
                    queue.offer(node.left);
                }
            }
            if (node.right != null) {
                if (!isLeafNode(node.right)) {
                    queue.offer(node.right);
                }
            }
        }
        return ans;
    }

    public boolean isLeafNode(TreeNode node) {
        return node.left == null && node.right == null;
    }
}