「这是我参与11月更文挑战的第17天，活动详情查看：2021最后一次更文挑战」

404. 左叶子之和

题目描述

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

示例：

    3
   / \
  9  20
    /  \
   15   7

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

解析

本题的难点在于如何确定是左叶子节点

• 判断条件：左子树不为空，左子树的左孩子和右孩子均为空

递归法

// 递归法
class Solution
{
public:
    int sumOfLeftLeaves(TreeNode *root)
    {
        return getValue(root);
    }
    int getValue(TreeNode *node)
    {
        if (node == NULL)
        {
            return 0;
        }
        // 左 右 中
        int leftVal = getValue(node->left);
        int rightVal = getValue(node->right);

        int midValue = 0;
        // 判断是否是左子树的叶子节点
        if (node->left && !node->left->left && !node->left->right)
        {
            midValue = node->left->val;
        }

        return midValue + leftVal + rightVal;
    }
};

迭代法

// 递归法
class Solution
{
public:
    int sumOfLeftLeaves(TreeNode *root)
    {
        if (root == NULL)
        {
            return 0;
        }

        int sum = 0;
        stack<TreeNode *> st;
        st.push(root);

        while (!st.empty())
        {

            int size = st.size();
            TreeNode *node = st.top();
            st.pop();

            // 判断左子树不为空，且左子树的左右孩子都为空
            if (node->left && !node->left->left && !node->left->right)
            {
                sum += node->left->val;
            }

            // 左
            if (node->left)
            {
                st.push(node->left);
            }

            // 右
            if (node->right)
            {
                st.push(node->right);
            }
        }
        return sum;
    }
};

找到左下角的值

题目描述

给定一个二叉树，在树的最后一行找到最左边的值。

示例 1:

示例 2:

解析

找到最深层最左侧的节点

递归法

// 递归法
// 前序遍历
// 最后一层的最左侧
class Solution
{
public:
    // 全局变量
    int maxLen;     // 最大深度
    int maxLeftVal; // 最大深度最左侧节点的值
    int getLeftNodeVal(TreeNode *root)
    {
        traversal(root, 0);
        return maxLeftVal;
    }

    // 1、确定递归函数的参数与返回值
    //      需要遍历整个树时，不能有返回值
    //      需要遍历某个路径时，需要有返回值
    void traversal(TreeNode *root, int leftLen)
    {
        // 2、终止递归的条件
        if (root->left == NULL && root->right == NULL)
        {
            if (leftLen > maxLen)
            {
                maxLen = leftLen;
                maxLeftVal = root->val;
            }
        }
        // 3、单层递归的逻辑
        if (root->left)
        {
            leftLen++;
            traversal(root->left, leftLen);
            leftLen--; //回溯
        }

        if (root->right)
        {
            leftLen++;
            traversal(root->right, leftLen);
            leftLen--;
        }
    }
};

迭代法

// 迭代法
// 层序遍历
class Solution
{
public:
    int getLeftNodeVal(TreeNode *root)
    {
        if (root == NULL)
        {
            return 0;
        }

        queue<TreeNode *> que;
        que.push(root);
        # 记录每层遍历的节点
        # 最后一层的第一个就是需要返回的值
        vector<vector<int>> result;

        while (!que.empty())
        {
            // 确定某一层的节点数
            int size = que.size();
            vector<int> v;
            // 遍历
            for (int i = 0; i < size; i++)
            {
                TreeNode *node = que.front();
                que.pop();
                # 记录节点的值
                v.push_back(node->val);
                # 存储下一层的节点
                if (node->left)
                {
                    que.push(node->left);
                }

                if (node->right)
                {
                    que.push(node->right);
                }
            }
            result.push_back(v);
        }

        int size = result.size();
        // 返回最深层的第一个节点值
        return result[size - 1][0];
    }
};