Welcome to Subscribe On Youtube

404. Sum of Left Leaves

Description

Given the root of a binary tree, return the sum of all left leaves.

A leaf is a node with no children. A left leaf is a leaf that is the left child of another node.

 

Example 1:

Input: root = [3,9,20,null,null,15,7]
Output: 24
Explanation: There are two left leaves in the binary tree, with values 9 and 15 respectively.

Example 2:

Input: root = [1]
Output: 0

 

Constraints:

  • The number of nodes in the tree is in the range [1, 1000].
  • -1000 <= Node.val <= 1000

Solutions

  • /**
     * 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;
            }
            int res = 0;
            if (root.left != null && root.left.left == null && root.left.right == null) {
                res += root.left.val;
            }
            res += sumOfLeftLeaves(root.left);
            res += sumOfLeftLeaves(root.right);
            return res;
        }
    }
    
  • # Definition for a binary tree node.
    # class TreeNode:
    #     def __init__(self, x):
    #         self.val = x
    #         self.left = None
    #         self.right = None
    
    
    class Solution:
        def sumOfLeftLeaves(self, root: TreeNode) -> int:
            if root is None:
                return 0
            res = 0
            if root.left and root.left.left is None and root.left.right is None:
                res += root.left.val
            res += self.sumOfLeftLeaves(root.left)
            res += self.sumOfLeftLeaves(root.right)
            return res
    
    
  • /**
     * Definition for a binary tree node.
     * type TreeNode struct {
     *     Val int
     *     Left *TreeNode
     *     Right *TreeNode
     * }
     */
    func sumOfLeftLeaves(root *TreeNode) int {
    	if root == nil {
    		return 0
    	}
    	res := 0
    	if root.Left != nil && root.Left.Left == nil && root.Left.Right == nil {
    		res += root.Left.Val
    	}
    	res += sumOfLeftLeaves(root.Left)
    	res += sumOfLeftLeaves(root.Right)
    	return res
    }
    
  • /**
     * Definition for a binary tree node.
     * class TreeNode {
     *     val: number
     *     left: TreeNode | null
     *     right: TreeNode | null
     *     constructor(val?: number, left?: TreeNode | null, right?: TreeNode | null) {
     *         this.val = (val===undefined ? 0 : val)
     *         this.left = (left===undefined ? null : left)
     *         this.right = (right===undefined ? null : right)
     *     }
     * }
     */
    
    const dfs = (root: TreeNode | null, isLeft: boolean) => {
        if (!root) {
            return 0;
        }
        const { val, left, right } = root;
        if (!left && !right) {
            if (isLeft) {
                return val;
            }
            return 0;
        }
        return dfs(left, true) + dfs(right, false);
    };
    
    function sumOfLeftLeaves(root: TreeNode | null): number {
        return dfs(root, false);
    }
    
    
  • // Definition for a binary tree node.
    // #[derive(Debug, PartialEq, Eq)]
    // pub struct TreeNode {
    //   pub val: i32,
    //   pub left: Option<Rc<RefCell<TreeNode>>>,
    //   pub right: Option<Rc<RefCell<TreeNode>>>,
    // }
    //
    // impl TreeNode {
    //   #[inline]
    //   pub fn new(val: i32) -> Self {
    //     TreeNode {
    //       val,
    //       left: None,
    //       right: None
    //     }
    //   }
    // }
    use std::rc::Rc;
    use std::cell::RefCell;
    impl Solution {
        fn dfs(root: &Option<Rc<RefCell<TreeNode>>>, is_left: bool) -> i32 {
            if root.is_none() {
                return 0;
            }
            let node = root.as_ref().unwrap().borrow();
            let left = &node.left;
            let right = &node.right;
            if left.is_none() && right.is_none() {
                if is_left {
                    return node.val;
                }
                return 0;
            }
            Self::dfs(left, true) + Self::dfs(right, false)
        }
    
        pub fn sum_of_left_leaves(root: Option<Rc<RefCell<TreeNode>>>) -> i32 {
            Self::dfs(&root, false)
        }
    }
    
    
  • /**
     * Definition for a binary tree node.
     * struct TreeNode {
     *     int val;
     *     TreeNode *left;
     *     TreeNode *right;
     *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
     *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
     *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
     * };
     */
    class Solution {
    public:
        int sumOfLeftLeaves(TreeNode* root) {
            if (!root) {
                return 0;
            }
            int ans = sumOfLeftLeaves(root->right);
            if (root->left) {
                if (!root->left->left && !root->left->right) {
                    ans += root->left->val;
                } else {
                    ans += sumOfLeftLeaves(root->left);
                }
            }
            return ans;
        }
    };
    
    

All Problems

All Solutions