LeetCode404. 左叶子之和

404. 左叶子之和

---

一、题目

给定二叉树的根节点 root ，返回所有左叶子之和。

示例 1：

输入: root = [3,9,20,null,null,15,7] 
输出: 24 
解释: 在这个二叉树中，有两个左叶子，分别是 9 和 15，所以返回 24

示例 2:

输入: root = [1]
输出: 0

提示:

• 节点数在 [1, 1000] 范围内
• -1000 <= Node.val <= 1000

二、题解

方法一：递归

算法思路：

题目要求计算二叉树中所有左叶子节点的值之和。我们可以使用递归来解决这个问题。递归的思想是，对于每个节点，我们判断它是否是左叶子节点，如果是，则将其值加到结果中，然后递归地处理它的左子树和右子树。

具体实现：

1. 我们首先定义一个变量 sum 来保存左叶子节点值的和，并初始化为0。

2. 在递归函数 sumOfLeftLeaves 中，我们首先检查当前节点是否为空，如果为空，则返回0。

3. 然后，我们检查当前节点的左子节点是否存在，以及左子节点是否为叶子节点。如果是叶子节点，则将其值加到 sum 中。

4. 最后，我们递归地处理当前节点的左子树和右子树，将它们的返回值累加到 sum 中。

5. 在每一层递归结束后，函数返回当前子树中左叶子节点的值之和。

/**
 * 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) {
        int sum = 0;
        if (root == nullptr) {
            return 0;
        }
        // 判断左子节点是否为叶子节点，如果是则将值加入 sum
        if (root->left && !root->left->left && !root->left->right) {
            sum += root->left->val;
        }
        // 递归处理左子树和右子树，并累加结果到 sum
        return sum + sumOfLeftLeaves(root->left) + sumOfLeftLeaves(root->right);
    }
};

算法分析：

1. 时间复杂度：遍历整个二叉树的时间复杂度为 O(N)，其中 N 是二叉树的节点数。在每个节点上，我们进行常数时间的判断和加法操作。

2. 空间复杂度：递归函数的调用会占用栈空间，递归的深度最坏情况下为树的高度，所以空间复杂度为 O(H)，其中 H 是二叉树的高度。在最坏情况下，二叉树可能退化为链表，高度为 N，此时空间复杂度为 O(N)。但在一般情况下，二叉树的高度平衡，空间复杂度会接近 O(logN)。

方法二：迭代

算法思路：

1. 我们可以使用深度优先搜索（DFS）来遍历二叉树，使用栈来辅助遍历。
2. 在遍历的过程中，对于每个节点，我们检查它的左子节点是否存在，如果存在，继续检查左子节点是否为叶子节点（即没有左右子节点）。如果是叶子节点，则将其值加到累加器 sum 中。
3. 对于非叶子节点，我们将左子节点压入栈，以便后续继续检查。
4. 然后，无论是否有右子节点，都将右子节点压入栈，以确保我们遍历了所有可能的路径。

具体实现：

class Solution {
public:
    int sumOfLeftLeaves(TreeNode* root) {
        stack<TreeNode*> st;
        int sum = 0;
        
        if (root == nullptr) {
            return 0;
        }
        
        st.push(root);
        
        while (!st.empty()) {
            TreeNode* node = st.top();
            st.pop();
            
            if (node->left) {
                if (!node->left->left && !node->left->right) {
                    sum += node->left->val; // 如果左子节点是叶子节点，将值加入 sum
                } else {
                    st.push(node->left); // 如果左子节点不是叶子节点，将左子节点压入栈
                }
            }
            
            if (node->right) {
                st.push(node->right); // 将右子节点压入栈，无论是否为叶子节点
            }
        }
        
        return sum;
    }
};

算法分析：

• 时间复杂度：遍历整个二叉树的时间复杂度为 O(N)，其中 N 是二叉树的节点数。在每个节点上，我们进行常数时间的判断、加法和栈操作。
• 空间复杂度：使用了一个栈来辅助遍历，栈的空间占用与二叉树的高度相关，最坏情况下为 O(N)。因此，总体空间复杂度为 O(N)。