404. 左叶子之和

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

我的解法：

思路：相当于树的广度优先遍历（BFS），使用一个队列。

class Solution {
public:
    int sumOfLeftLeaves(TreeNode* root) {
        queue<TreeNode*> q;
        q.push(root);
        int res=0;
        while(!q.empty()){
            TreeNode* t=q.front();
            q.pop();
            if(t->left){//有左子树
                q.push(t->left);
                if(!t->left->left&&!t->left->right)//这个左子树为左叶子
                {
                    res+=t->left->val;
                    q.pop();
                }    
            }             
            if(t->right)//有右子树
                q.push(t->right);
        }
        return res;
    }
};

问题：runtime error: member access within null pointer of type ‘TreeNode’ (solution.cpp)
发现问题：t有可能为空指针。

改进1.0：

class Solution {
public:
    int sumOfLeftLeaves(TreeNode* root) {
        queue<TreeNode*> q;
        q.push(root);
        int res=0;
        while(!q.empty()){
            TreeNode* t=q.front();
            q.pop();
            if(!t)//t为null
                continue;
            if(t->left){//有左子树
                q.push(t->left);
                if(!t->left->left&&!t->left->right)//这个左子树为左叶子
                    res+=t->left->val;
            }             
            if(t->right)//有右子树
                q.push(t->right);
        }
        return res;
    }
};

思路：使用一个队列，所有元素依次入队，出队时，验证符合条件的加和。
数据结构：队列
时间复杂度：O(n) 空间复杂度：O(n)
总结：第一次完全独立解决了问题，小有成就感。I just solved on LeetCode. My cpp solution finished in 4 ms, beating 89.39% of all other cpp submissions.

思路2.0 树的DFS

class Solution {
public:
    //是否为叶子结点
    bool isLeadNode(TreeNode* node){
        return !node->left&&!node->right;
    }
    //深度优先遍历
    int dfs(TreeNode* node){
        int ans=0;
        //有左子树
        if(node->left){
            //判断左子树是否为叶子结点，是加和，否深度遍历
            ans+=isLeadNode(node->left)?node->left->val:dfs(node->left);
        }
        //有右子树
        if(node->right){
            //直接继续遍历
            ans+=dfs(node->right);
        }
        return ans;
    }
    int sumOfLeftLeaves(TreeNode* root) {
        return root?dfs(root):0;
    }
};

时间复杂度：O(n) 空间复杂度：O(n)。
dfs使用了递归。