计算二叉树左叶子之和

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

示例1：

3

/ \

9 20

/ \

15 7

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

示例2:

1

\

2

在这个二叉树中，没有左叶子，返回0

思路：本题的关键在于如何判断是不是左叶子？平时我们解二叉树的题目时，已经习惯了通过节点的左右孩子判断本节点的属性，而本题我们要通过节点的父节点判断本节点的属性，该题可以扩展大家对二叉树的解题思路。

具体方法为：判断父节点的左不为空，且父的左的左为空，且父的左的右为空。因此可以遍历整个二叉树，判断遍历到的每个节点node，判断该node是否满足如下条件，如果满足则将结果值加上该节点做子节点的值，接着再处理左子树和右子树。

if(node->left && !node->left->left && !node->left->right)
    result += node->left->val;

此时问题已经转化成对二叉树的遍历了。

顺便提一下，遍历可以分为深度优先和广度优先。

深度优先：前中后序遍历，可以使用递归和迭代两种方法，迭代使用栈。

广度优先：层序遍历，使用迭代方法，使用队列。

前序遍历-递归实现：

/**
* 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 sumsum(TreeNode* node){
        if(!node) return 0;
        
        int value = 0;
        if(node->left && node->left->left == NULL && node->left->right == NULL)
            value = node->left->val;

        return value + sumsum(node->left) + sumsum(node->right);
    }

    int sumOfLeftLeaves(TreeNode* root) {
        return sumsum(root);
    }
};

前序遍历-栈实现：

/**
* 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 result = 0;
        stack<TreeNode*> st;
        st.push(root);

        while(st.size()){
            TreeNode* node = st.top();
            st.pop();
            if(node->left && !node->left->left && !node->left->right)
                result += node->left->val;
            
            if(node->left) st.push(node->left);
            if(node->right) st.push(node->right);
        }

        return result;
    }
};

层序遍历-队列实现：

/**
* 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 result = 0;
        queue<TreeNode*> que;
        que.push(root);
        while(que.size()){
            int size = que.size();
            for(int i = 0; i < size; i++){
                TreeNode* node = que.front();
                que.pop();
                if(node->left && !node->left->left && !node->left->right)
                    result += node->left->val;

                if(node->left) que.push(node->left);
                if(node->right) que.push(node->right);
            }
        }

        return result;
    }
};