Approach: BFS; record the first node of each level

def findBottomLeftValue(self, root):
    from collections import deque
    q = deque([root]); res = root.val
    while q:
        res = q[0].val
        for _ in range(len(q)):
            n = q.popleft()
            if n.left: q.append(n.left)
            if n.right: q.append(n.right)
    return res

Complexity: O(n) time, O(w) space.

Full Solution — all languages

class TreeNode:
    def __init__(self, val=0, left=None, right=None):
        self.val = val
        self.left = left
        self.right = right

class Solution:
    def findBottomLeftValue(self, root):
        from collections import deque
        q = deque([root]); res = root.val
        while q:
            res = q[0].val
            for _ in range(len(q)):
                n = q.popleft()
                if n.left: q.append(n.left)
                if n.right: q.append(n.right)
        return res

import java.util.*;
class TreeNode {
    int val;
    TreeNode left, right;
    TreeNode(int v) {
        val = v;
    }
}
class Solution {
    public int findBottomLeftValue(TreeNode root) {
        Queue<TreeNode> q = new LinkedList<>();
        q.add(root);
        int res = root.val;
        while (!q.isEmpty()) {
            int sz = q.size();
            res = q.peek().val;
            for (int i = 0; i < sz; i++) {
                TreeNode n = q.poll();
                if (n.left != null) q.add(n.left);
                if (n.right != null) q.add(n.right);
            }
        }
        return res;
    }
}

#include <bits/stdc++.h> using namespace std;
struct TreeNode {
    int val;
    TreeNode *left, *right;
    TreeNode(int v): val(v), left(nullptr), right(nullptr) {
    }
};
class Solution {
    public: int findBottomLeftValue(TreeNode* root) {
        queue<TreeNode*> q;
        q.push(root);
        int res = root->val;
        while (!q.empty()) {
            int sz = q.size();
            res = q.front()->val;
            for (int i = 0; i < sz; i++) {
                TreeNode* n = q.front();
                q.pop();
                if (n->left) q.push(n->left);
                if (n->right) q.push(n->right);
            }
        }
        return res;
    }
};

/**
 * Tree node shape: { val, left, right }
 * @param {TreeNode} root
 * @return {number}
 */ var findBottomLeftValue = function(root) {
    let q = [root], res = root.val;
    while (q.length) {
        res = q[0].val;
        const nq = [];
        for (const n of q) {
            if (n.left) nq.push(n.left);
            if (n.right) nq.push(n.right);
        }
        q = nq;
    }
    return res;
};

Find Bottom Left Tree Value

Example 1

Example 2

Constraints