[LeetCode]404. Sum of left leaves

This is my answer now ！ 2022 year 6 month 26 Japan 22:33:43

It just took me less than estimated 10min make .

  public int sumOfLeftLeaves(TreeNode root) {
    
        // At first, I still think of using recursion  2022 year 6 month 26 Japan 22:23:46
        if(root == null){
    
            return 0;
        }
        int result = 0;
        TreeNode left = root.left;
        TreeNode right = root.right;
        if(left != null){
    
            if(left.left == null && left.right == null){
    
                result += left.val;
            }else{
    
                result += sumOfLeftLeaves(left);
 
            }
            if(left.left != null){
    

            }
        }
        result += sumOfLeftLeaves(right);
        return result;
    }

Then I found that my original code was too bloated , I can't see it at all ！

Poor readability ！

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

        if (root.left == null && root.right == null) {
    
            return 0;
        }

        // Leaf node   A node without children .
        int sum = 0;
        sum += sumByRecusiveSelf( root.left, true);
        sum += sumByRecusiveSelf( root.right, false);
        return sum;
    }

    private int sumByRecusiveSelf(TreeNode node, boolean isLeft) {
    
        if (node == null) {
    
            return 0;
        }
        if (node.left == null && node.right == null) {
    
            //  The left leaf just returns => Added to the result 
            if (isLeft) {
    
                return node.val;
            } else {
    
                return 0;
            }
        }

        int result = 0;
        result += sumByRecusiveSelf(node.left, true);
        result += sumByRecusiveSelf(node.right, false);
        return result;
    }

Do you want to judge whether the left node , You don't need it at all , direct null You can also use recursive methods , It will return anyway 0 ah ！

Look at the solution ！

Method two doesn't go away , The stack is used .

Method 1 is actually the same as my current writing , Take a good look .

complete .

Method 1 ： Depth-first search

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;
    }
}