代码随想录算法训练营第23天|LeetCode404.左叶子之和、LeetCode513.找树左下角的值

代码随想录算法训练营第23天|LeetCode404.左叶子之和、LeetCode513.找树左下角的值

1、LeetCode404.左叶子之和

404. 左叶子之和 - 力扣（LeetCode）

第一想法：先序遍历递归法。

我写的递归三部曲：

1. 函数参数和返回值

void preorder(TreeNode* root, bool left)。left表示是否是左节点。

2. 终止条件

当root节点为叶子节点&&左叶子节点时，sum加和，返回。

3. 单层递归逻辑

若左子节点不为空，则继续递归，并且传入left为1；右子节点同，但传入的left为0.

递归代码：

一遍过！

class Solution {
public:
    int sum = 0;
    void preorder(TreeNode* root, bool left){
        if(root == NULL)    return;
        // 是左叶子节点
        if(root->left == NULL && root->right == NULL && left){
            sum += root->val;
            return ;
        }
        // 不是叶子节点
        if(root->left){
            preorder(root->left, 1);
        }
        if(root->right){
            preorder(root->right, 0);
        }

    }
    int sumOfLeftLeaves(TreeNode* root) {
        if(root == NULL)
            return sum;
        preorder(root, 0);
        return sum;
    }
};

迭代法

没有自己写代码，但是很好理解。

但判断是否是左子节点的思路和我不一样

class Solution {
public:
    int sumOfLeftLeaves(TreeNode* root) {
        stack<TreeNode*> st;
        if (root == NULL) return 0;
        st.push(root);
        int result = 0;
        while (!st.empty()) {
            TreeNode* node = st.top();
            st.pop();
            if (node->left != NULL && node->left->left == NULL && node->left->right == NULL) {
                result += node->left->val;
            }
            if (node->right) st.push(node->right);
            if (node->left) st.push(node->left);
        }
        return result;
    }
};

2、LeetCode513.找树左下角的值

513. 找树左下角的值 - 力扣（LeetCode）

第一想法（迭代法）

（其实看到了提示说迭代法更简便所以就先想了迭代法）使用层序遍历的迭代法，在每一层遍历时，将队列中第1个元素——即该层最左边元素，保存下来。这样每一层都会被覆盖，这样最后返回的即最后一层的最左边。

迭代代码

一次过！

class Solution {
public:
    int findBottomLeftValue(TreeNode* root) {
        queue<TreeNode*> que;
        que.push(root);
        TreeNode* res;
        while(!que.empty()){
            int size = que.size();
          	// 这一层的最左边
            res = que.front();
            for(int i=0 ; i<size ; i++){
                TreeNode* front = que.front();
                que.pop();
                if(front->left)
                    que.push(front->left);
                if(front->right)
                    que.push(front->right);
            }
        }
        return res->val;
    }
};

递归法

没有自己手写代码。

问题：如何保证一定是最左边的节点呢？

我知道了：从depth>maxdepth可以确定。因为先对左节点进行递归，此时已经更新了maxdepth，与左节点等深的右节点若也是叶子，但是不符合>的条件。因此可以确定是最左边。

class Solution {
public:
    int maxDepth = INT_MIN;
    int result;
    void traversal(TreeNode* root, int depth) {
        if (root->left == NULL && root->right == NULL) {
            if (depth > maxDepth) {
                maxDepth = depth;
                result = root->val;
            }
            return;
        }
        if (root->left) {
            traversal(root->left, depth + 1); // 隐藏着回溯
        }
        if (root->right) {
            traversal(root->right, depth + 1); // 隐藏着回溯
        }
        return;
    }
    int findBottomLeftValue(TreeNode* root) {
        traversal(root, 0);
        return result;
    }
};