Find Bottom Left Tree Value - Practice Coding Problems

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.

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.

Time & Space Complexity

Time Complexity

⏱️

O(n)

Visit each node once to collect data, then scan through collected nodes

✓ Linear Growth

Space Complexity

O(n)

Store information for all nodes in the tree

⚡ Linearithmic Space

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

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
✓ 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	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) — Algorithm Steps

Traverse the entire tree using DFS
Record each node's value, depth, and horizontal position
Find the maximum depth among all nodes
Filter nodes that are at the maximum depth
Return the leftmost node among the filtered nodes

Visualization

Tap to expand

Step-by-Step Walkthrough

Traverse Tree

Visit every node and collect (value, depth, position)

Find Max Depth

Scan through collected data to find the deepest level

Filter Bottom Level

Keep only nodes at the maximum depth

Find Leftmost

Among bottom level nodes, find the one with smallest position

Code -

solution.c — C

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

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

struct NodeInfo {
    int val, depth, pos;
};

static struct NodeInfo nodes[1000];
static int nodeCount = 0;

void dfs(struct TreeNode* node, int depth, int pos) {
    if (!node) return;
    nodes[nodeCount++] = (struct NodeInfo){node->val, depth, pos};
    dfs(node->left, depth + 1, pos * 2);
    dfs(node->right, depth + 1, pos * 2 + 1);
}

int findBottomLeftValue(struct TreeNode* root) {
    nodeCount = 0;
    dfs(root, 0, 0);
    
    int maxDepth = 0;
    for (int i = 0; i < nodeCount; i++) {
        if (nodes[i].depth > maxDepth) {
            maxDepth = nodes[i].depth;
        }
    }
    
    int leftmostPos = INT_MAX;
    int result = 0;
    for (int i = 0; i < nodeCount; i++) {
        if (nodes[i].depth == maxDepth && nodes[i].pos < leftmostPos) {
            leftmostPos = nodes[i].pos;
            result = nodes[i].val;
        }
    }
    
    return result;
}

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

Time & Space Complexity

Time Complexity

⏱️

O(n)

Visit each node once to collect data, then scan through collected nodes

✓ Linear Growth

Space Complexity

O(n)

Store information for all nodes in the tree

⚡ Linearithmic Space

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

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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Brute Force (DFS All Nodes + Second Pass) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler