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

本文讨论了LeetCode中的两个问题:404左叶子之和,使用了递归和迭代方法求解;513找树左下角的值,通过迭代层序遍历找到最左边的节点。作者展示了两种不同的解决方案并解释了其工作原理。
摘要由CSDN通过智能技术生成

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

1、LeetCode404.左叶子之和

404. 左叶子之和 - 力扣(LeetCode)

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

我写的递归三部曲:
  1. 函数参数和返回值

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

  1. 终止条件

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

  1. 单层递归逻辑

若左子节点不为空,则继续递归,并且传入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;
    }
};
  • 9
    点赞
  • 3
    收藏
    觉得还不错? 一键收藏
  • 1
    评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值