Codestin Search App

Find Bottom Left Tree Value - Problem

Given the root of a binary tree, you need to find the leftmost value in the bottom row of the tree.

Think of it as looking at a binary tree from above and wanting to know what value sits at the leftmost position of the deepest level. The tree is guaranteed to have at least one node, so there will always be a bottom-left value to find.

Goal: Return the leftmost value in the last row of the binary tree.

Input: Root node of a binary tree

Output: Integer value of the leftmost node in the deepest level

Example: In a tree where the bottom row contains [7, 4], return 7 since it's the leftmost value in that row.

Input & Output

example_1.py — Basic Binary Tree

$ Input: [2,1,3,7,4]

› Output: 7

💡 Note: The tree has levels: Level 0: [2], Level 1: [1,3], Level 2: [7,4]. The leftmost value in the last row is 7.

example_2.py — Single Node

$ Input: [1]

› Output: 1

💡 Note: The tree has only one node, so the leftmost value in the bottom row is 1.

example_3.py — Left-Heavy Tree

$ Input: [1,2,3,4,null,5,6,null,null,7]

› Output: 7

💡 Note: The tree has multiple levels with the deepest level containing only node 7, making it the leftmost (and only) value in the bottom row.

Constraints

The number of nodes in the tree is in the range [1, 10⁴]
-2³¹ ≤ Node.val ≤ 2³¹ - 1
It's guaranteed that the tree has at least one node

Visualization

Tap to expand

Understanding the Visualization

Enter Building

Start at the lobby (root) with your elevator (queue)

Visit Each Floor

Process all offices on each floor from left to right

Track Leftmost Office

Remember the first office visited on each floor

Reach Bottom Floor

The last floor processed gives us the leftmost office

Key Takeaway

🎯 Key Insight: BFS naturally processes nodes level by level from left to right, so the first node we encounter at each level is guaranteed to be the leftmost node at that level.

Asked in

a Amazon 15 ⊞ Microsoft 12 f Facebook 8 G Google 6

The optimal approach uses BFS (Breadth-First Search) to traverse the tree level by level. Since BFS processes nodes from left to right at each level, the first node encountered at the deepest level is guaranteed to be the leftmost node. This solution has O(n) time complexity and O(w) space complexity where w is the maximum width of the tree.

Common Approaches

Approach	Time	Space	Notes
✓ DFS with Global Variables	O(n)	O(h)	Use DFS to find the leftmost node at maximum depth using global tracking
BFS Level Order Traversal (Optimal)	O(n)	O(w)	Use BFS to traverse level by level, the first node at the deepest level is the answer
Brute Force (DFS All Nodes + Second Pass)	O(n)	O(n)	Find all leaf nodes and their depths, then select the leftmost among the deepest

DFS with Global Variables — Algorithm Steps

Initialize variables to track max depth and result value
Perform DFS traversal of the tree
For each node, check if it's at a deeper level than current max
If deeper level found, update max depth and result
If same level but leftmost position, update result
Return the final result

Visualization

Tap to expand

Step-by-Step Walkthrough

Start DFS

Begin traversal from root with depth 0

Track Max Depth

Update result when finding a deeper level

Process Left First

Left children are processed before right children

Return Result

The leftmost node at maximum depth

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>

struct TreeNode {
    int val;
    struct TreeNode *left;
    struct TreeNode *right;
};

static int maxDepth = -1;
static int result = 0;

void dfs(struct TreeNode* node, int depth) {
    if (!node) return;
    
    if (depth > maxDepth) {
        maxDepth = depth;
        result = node->val;
    }
    
    dfs(node->left, depth + 1);
    dfs(node->right, depth + 1);
}

int findBottomLeftValue(struct TreeNode* root) {
    maxDepth = -1;
    result = 0;
    dfs(root, 0);
    return result;
}

int main() {
    // Tree parsing implementation would go here
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Visit each node exactly once during DFS traversal

✓ Linear Growth

Space Complexity

O(h)

Recursion stack depth equals tree height h

✓ Linear Space

89.0K Views

Medium Frequency

~15 min Avg. Time

2.3K Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

DFS with Global Variables — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler