Question

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

Solution 1

# 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.
 * 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.
 * 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;
 *   struct TreeNode *left;
 *   struct TreeNode *right;
 * };
 */

int dfs(struct TreeNode* root, int isLeft) {
  if (!root) {
    return 0;
  }
  if (!root->left && !root->right) {
    return isLeft ? root->val : 0;
  }
  return dfs(root->left, 1) + dfs(root->right, 0);
}

int sumOfLeftLeaves(struct TreeNode* root) {
  return dfs(root, 0);
}