Find Bottom Left Tree Value

Find Bottom Left Tree Value - Problem

Given the root of a binary tree, return the leftmost value in the last row of the tree.

You need to find the value of the leftmost node in the bottom-most level of the tree. If there are multiple nodes at the same level, return the leftmost one.

Note: The tree is guaranteed to be non-empty.

Input & Output

Example 1 — Standard Tree

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

› Output: 7

💡 Note: The bottom level has one node: 7. This is the leftmost (and only) value in the last row.

Example 2 — Multiple Bottom Nodes

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

› Output: 4

💡 Note: The bottom level has nodes [4,5,6]. The leftmost value is 4.

Example 3 — Single Node

$ Input: root = [1]

› Output: 1

💡 Note: Only one node exists, so it's the leftmost value in the last (and only) row.

Constraints

The number of nodes in the tree is in the range [1, 10⁴]
-2³¹ ≤ Node.val ≤ 2³¹ - 1

Visualization

Tap to expand

Asked in

G Google 15 a Amazon 12 M Microsoft 10 Apple 8

The key insight is to find the leftmost node in the bottom-most level of the tree. The BFS approach is optimal as it processes nodes level by level, naturally identifying the first (leftmost) node at each level. Time: O(n), Space: O(w) where w is maximum tree width.

Common Approaches

✓ Optimized

⏱️ Time: N/A Space: N/A

DFS with Level Tracking

⏱️ Time: O(n) Space: O(h)

Traverse the entire tree using depth-first search, keeping track of the maximum depth encountered and the leftmost value at that depth. For each node, if we find a deeper level, update our result.

Level-Order Traversal (BFS)

⏱️ Time: O(n) Space: O(w)

Process the tree level by level using a queue. For each level, the first node we encounter is the leftmost node. Keep updating our answer as we go deeper until we reach the bottom level.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

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

#define MAX_SIZE 1000

typedef struct {
    int num;
    int count;
} FreqEntry;

int solution(int* arr, int size) {
    FreqEntry freq[MAX_SIZE];
    int freqSize = 0;
    
    // First pass: count frequencies
    for (int i = 0; i < size; i++) {
        int num = arr[i];
        int found = 0;
        
        for (int j = 0; j < freqSize; j++) {
            if (freq[j].num == num) {
                freq[j].count++;
                found = 1;
                break;
            }
        }
        
        if (!found) {
            freq[freqSize].num = num;
            freq[freqSize].count = 1;
            freqSize++;
        }
    }
    
    // Second pass: find largest lucky number
    int maxLucky = -1;
    for (int i = 0; i < freqSize; i++) {
        if (freq[i].count == freq[i].num) {
            if (maxLucky == -1 || freq[i].num > maxLucky) {
                maxLucky = freq[i].num;
            }
        }
    }
    
    return maxLucky;
}

void parseArray(const char* str, int* arr, int* size) {
    *size = 0;
    const char* p = str;
    while (*p && *p != '[') p++;
    if (*p == '[') p++;
    while (*p && *p != ']') {
        while (*p == ' ' || *p == ',') p++;
        if (*p == ']' || *p == '\0') break;
        arr[(*size)++] = (int)strtol(p, (char**)&p, 10);
    }
}

int main() {
    char line[1000];
    fgets(line, sizeof(line), stdin);
    
    // Parse array
    int arr[MAX_SIZE];
    int size = 0;
    char* token = strtok(line + 1, ",]");
    while (token != NULL) {
        arr[size++] = atoi(token);
        token = strtok(NULL, ",]");
    }
    
    int result = solution(arr, size);
    printf("%d\n", result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

✓ Linear Growth

Space Complexity

✓ Linear Space

180.0K Views

Medium Frequency

~15 min Avg. Time

2.2K 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