力扣第513题 找树左下角的值 c++ 递归 迭代 回溯

题目

513. 找树左下角的值

中等

给定一个二叉树的 根节点 root，请找出该二叉树的 最底层 最左边 节点的值。

假设二叉树中至少有一个节点。

示例 1:

输入: root = [2,1,3]
输出: 1

示例 2:

输入: [1,2,3,4,null,5,6,null,null,7]
输出: 7

提示:

• 二叉树的节点个数的范围是 [1,104]
• -231 <= Node.val <= 231 - 1 

思路和解题方法一（递归）

1. "class Solution" 定义了一个名为 "Solution" 的类。
2. "public:" 定义了类的公有成员和方法的访问权限。
3. "int maxDepth = INT_MIN;" 这行代码定义了一个整型变量 maxDepth，并初始化为 INT_MIN。INT_MIN 是在 c++ 中定义的整型最小值。
4. "int result;" 这行代码定义了一个整型变量 result。
5. "void traversal(TreeNode* root, int depth)" 这行代码定义了一个名为 traversal 的方法，它接受一个 TreeNode 类型的指针和一个整型数作为参数。这个方法是用来遍历二叉树的。
6. "if (root->left == NULL && root->right == NULL)" 是判断当前节点是否为叶子节点的条件。如果是，就执行后面的代码。
7. "if (depth > maxDepth)" 是判断当前深度是否大于之前的最大深度。如果是，就更新 maxDepth 的值，并把当前节点的值赋给 result。
8. "if (root->left)" 和 "if (root->right)" 是判断当前节点是否有左孩子和右孩子。如果有，就分别对左孩子和右孩子进行递归调用，深度加一。
9. "int findBottomLeftValue(TreeNode* root)" 是定义了一个方法，这个方法接受一个 TreeNode 类型的指针作为参数，返回一个整型数。这个方法是用来找到二叉树的最左边叶子节点的值，使用前面定义的 maxDepth。

复杂度

        时间复杂度:

                O(n)

时间复杂度为 O(n)，其中 n 表示二叉树的节点数。因为需要遍历每一个节点，且每个节点只会被访问一次。

        空间复杂度

                O(h)

空间复杂度为 O(h)，其中 ℎh 表示二叉树的高度。因为在递归过程中需要使用到系统栈，当二叉树退化为链式结构时，递归深度将会达到 ℎh，即空间复杂度为 O(h)。而当二叉树比较平衡时，递归深度将会小于 ℎh，空间复杂度也会相应地减小。

c++ 代码

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); // 遍历左子树，并将深度加1
        }
        if (root->right) {
            traversal(root->right, depth + 1); // 遍历右子树，并将深度加1
        }
        return;
    }

    int findBottomLeftValue(TreeNode* root) {
        traversal(root, 0); // 从根节点开始遍历，初始深度为0
        return result; // 返回结果值
    }
};

思路和解题方法二（迭代）

1. 创建一个队列 que，并将根节点 root 入队。
2. 初始化变量 result 为 0，用于记录最后一行第一个元素的值。
3. 当队列不为空时，执行以下操作：
   • 获取当前队列的大小 size，表示当前层的节点数。
   • 迭代遍历当前层的所有节点，从队列中取出节点 node：
     • 如果 i 等于 0（表示当前节点是当前层的第一个节点），则将 node 的值赋给 result。
     • 将 node 的左孩子节点入队（如果存在）。
     • 将 node 的右孩子节点入队（如果存在）。
4. 返回 result，即为最底层最左边的节点值。

利用了队列先进先出的特性，在每一层遍历时，始终保证队列中存储的是当前层的所有节点。最后一次循环结束后，result 中就存储了最后一行第一个节点的值。

复杂度

        时间复杂度:

                O(n)

时间复杂度为O(n)，其中n是二叉树中节点的数量，每个节点只会入队出队一次。

        空间复杂度

                O(h)

空间复杂度为O(m)，其中m是二叉树中最大层的节点数量，即队列的最大长度。

c++ 代码

// 定义Solution类
class Solution {
public:
    // 定义一个公有方法，该方法用于找到二叉树最左下角的节点的值
    int findBottomLeftValue(TreeNode* root) {
        // 定义一个队列，用于层序遍历二叉树
        queue<TreeNode*> que;
        // 如果二叉树的根节点不为空，则将其加入队列
        if (root != NULL) que.push(root);
        // 定义一个变量用于存储结果值
        int result = 0;
        // 当队列不为空时，进行循环
        while (!que.empty()) {
            // 获取当前队列的大小
            int size = que.size();
            // 对当前队列的每一个元素进行遍历
            for (int i = 0; i < size; i++) {
                // 获取队列的第一个元素，即当前层的第一个节点
                TreeNode* node = que.front();
                // 从队列中移除该元素
                que.pop();
                // 如果这是当前层的第一个元素（即最后一行的第一个元素）
                // 则将其值赋给result，用于记录
                if (i == 0) result = node->val; // 记录最后一行第一个元素
                // 如果当前节点的左子节点存在，则将其加入队列
                if (node->left) que.push(node->left);
                // 如果当前节点的右子节点存在，则将其加入队列
                if (node->right) que.push(node->right);
            }
        }
        // 返回结果值
        return result;
    }
};

觉得有用的话可以点点赞，支持一下。

如果愿意的话关注一下。会对你有更多的帮助。

每天都会不定时更新哦  >人<  。