Left Side View of Binary Tree in DSA Javascript

Mental Model

We want to see the nodes visible when looking at the tree from the left side, which means the first node at each level.

Analogy: Imagine standing on the left side of a tall building with many floors. You only see the first window on each floor from your side, even if there are more windows behind it.

      1
     / \
    2   3
   / \   \
  4   5   6

Left side view: 1 -> 2 -> 4 -> null

Dry Run Walkthrough

Input: Binary tree: 1 with left child 2 and right child 3; 2 has children 4 and 5; 3 has right child 6

Goal: Find the leftmost node at each level to form the left side view

Step 1: Start at root node 1, add it to the view as first level's leftmost

Level 0: [1]
Left side view so far: 1

Why: Root is always visible from the left side

Step 2: Move to level 1, nodes are 2 and 3; add 2 as leftmost node

Level 1: [2, 3]
Left side view so far: 1 -> 2

Why: At level 1, node 2 is the first visible from left

Step 3: Move to level 2, nodes are 4, 5, and 6; add 4 as leftmost node

Level 2: [4, 5, 6]
Left side view so far: 1 -> 2 -> 4

Why: At level 2, node 4 is the first visible from left

Result:

1 -> 2 -> 4 -> null

Annotated Code

DSA Javascript

class TreeNode {
  constructor(val = 0, left = null, right = null) {
    this.val = val;
    this.left = left;
    this.right = right;
  }
}

function leftSideView(root) {
  if (!root) return [];
  const result = [];
  const queue = [root];

  while (queue.length > 0) {
    const levelSize = queue.length;
    for (let i = 0; i < levelSize; i++) {
      const node = queue.shift();
      if (i === 0) result.push(node.val); // first node at this level
      if (node.left) queue.push(node.left); // add left child
      if (node.right) queue.push(node.right); // add right child
    }
  }
  return result;
}

// Driver code
const root = new TreeNode(1,
  new TreeNode(2, new TreeNode(4), new TreeNode(5)),
  new TreeNode(3, null, new TreeNode(6))
);
const view = leftSideView(root);
console.log(view.join(' -> ') + ' -> null');

if (!root) return [];

handle empty tree edge case

const queue = [root];

initialize queue for level order traversal

const levelSize = queue.length;

determine number of nodes at current level

for (let i = 0; i < levelSize; i++) {

iterate over all nodes at current level

const node = queue.shift();

remove node from front of queue to process

if (i === 0) result.push(node.val);

add first node of level to left side view

if (node.left) queue.push(node.left);

enqueue left child for next level

if (node.right) queue.push(node.right);

enqueue right child for next level

Output

1 -> 2 -> 4 -> null

Complexity Analysis

Time: O(n) because we visit each node exactly once during the level order traversal

Space: O(n) because in the worst case the queue can hold all nodes at the last level

vs Alternative: Compared to a recursive DFS approach, this BFS approach naturally processes nodes level by level, making it straightforward to pick the first node at each level without extra bookkeeping

Edge Cases

Empty tree (root is null)

Returns an empty list since there are no nodes to view

DSA Javascript

if (!root) return [];

Tree with only one node

Returns a list with just that one node value

DSA Javascript

const queue = [root];

Tree where some nodes have only right children

Still correctly picks the first node at each level, even if left child is missing

DSA Javascript

if (node.left) queue.push(node.left);

When to Use This Pattern

When you need to find the visible nodes from the left side of a tree, use level order traversal and pick the first node at each level to get the left side view.

Common Mistakes

Mistake: Adding all nodes at each level instead of only the first node
Fix: Only add the node value when processing the first node at each level (i === 0)

Mistake: Using preorder DFS without tracking levels properly
Fix: Use BFS or track levels carefully in DFS to ensure only the leftmost node per level is added

Summary

Finds the first visible node at each level when looking at a binary tree from the left side.

Use it when you want to see the leftmost nodes of each level in a tree.

The key insight is to do a level order traversal and pick the first node at each level.