Left Side View of Binary Tree in DSA Typescript

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 and only seeing the first window on each floor from your view.

      1
     / \
    2   3
   / \   \
  4   5   6

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

Dry Run Walkthrough

Input: Binary tree: 1 -> 2, 3 -> 4, 5, null, 6 (levels: root=1, level2=2,3, level3=4,5,null,6)

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

Step 1: Start at root node 1, add it to left side view

Level 1: [1↑]
Left side view: 1 -> null

Why: Root is always visible from the left side

Step 2: Move to level 2, nodes 2 and 3; add leftmost node 2 to view

Level 2: [2↑] -> 3
Left side view: 1 -> 2 -> null

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

Step 3: Move to level 3, nodes 4, 5, null, 6; add leftmost node 4 to view

Level 3: [4↑] -> 5 -> null -> 6
Left side view: 1 -> 2 -> 4 -> null

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

Result:

1 -> 2 -> 4 -> null

Annotated Code

DSA Typescript

class TreeNode {
  val: number;
  left: TreeNode | null;
  right: TreeNode | null;
  constructor(val?: number, left?: TreeNode | null, right?: TreeNode | null) {
    this.val = val === undefined ? 0 : val;
    this.left = left === undefined ? null : left;
    this.right = right === undefined ? null : right;
  }
}

function leftSideView(root: TreeNode | null): number[] {
  if (!root) return [];
  const result: number[] = [];
  const queue: TreeNode[] = [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 is visible from left
      }
      if (node.left) queue.push(node.left); // add left child for next level
      if (node.right) queue.push(node.right); // add right child for next level
    }
  }
  return result;
}

// Driver code to build tree and print left side view
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: TreeNode[] = [root];

initialize queue for level order traversal

const levelSize = queue.length;

determine number of 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 once during level order traversal

Space: O(n) because the queue can hold up to all nodes at the widest level

vs Alternative: Compared to recursive DFS, this BFS approach naturally processes nodes level by level, making it easier to pick the first node at each level without extra depth tracking.

Edge Cases

Empty tree (root is null)

Returns empty list since no nodes exist

DSA Typescript

if (!root) return [];

Tree with only root node

Returns list with only root value

DSA Typescript

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

Tree with missing left children at some levels

Still picks first node at each level, which may be a right child

DSA Typescript

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

When to Use This Pattern

When asked to find the visible nodes from one 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: Trying to do this with simple preorder traversal without tracking levels
Fix: Use level order traversal (BFS) to process nodes level by level and pick the first node at each level

Mistake: Adding all nodes at a level instead of only the first
Fix: Add only the first node encountered at each level (i === 0) to the result

Summary

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

Use when you need to see the leftmost nodes of a binary tree level by level.

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

Practice

1. What does the Left Side View of a binary tree represent?

easy

A. Nodes visible when the tree is viewed from the right side

B. Nodes at the deepest level of the tree

C. All leaf nodes of the tree

D. Nodes visible when the tree is viewed from the left side

Solution

1. Step 1: Understand the view perspective

   The left side view shows nodes visible when looking at the tree from the left side.

2. Step 2: Identify visible nodes

   Only the first node at each level from the left is visible in this view.

3. Final Answer:

   Nodes visible when the tree is viewed from the left side -> Option D

4. Quick Check:

   Left side view = nodes visible from left [OK]

Hint: Left side view shows first node at each level from left [OK]

Common Mistakes:

• Confusing left side view with right side view
• Thinking it shows all leaf nodes
• Assuming it shows deepest nodes only

2. Which of the following TypeScript function signatures correctly represents a function to get the left side view of a binary tree?

easy

A. function leftSideView(root: number[]): number

B. function leftSideView(root: TreeNode | null): number[]

C. function leftSideView(root: TreeNode): void

D. function leftSideView(root: string): string[]

Solution

1. Step 1: Identify correct input type

   The function should accept a binary tree root node or null, so TreeNode | null is correct.

2. Step 2: Identify correct return type

   The function returns an array of numbers representing node values visible from the left side.

3. Final Answer:

   function leftSideView(root: TreeNode | null): number[] -> Option B

4. Quick Check:

   Input = TreeNode or null, Output = number array [OK]

Hint: Input is tree root or null; output is array of numbers [OK]

Common Mistakes:

• Using array of numbers as input instead of tree node
• Returning void instead of array
• Using wrong input type like string

3. Given the binary tree below, what is the left side view output?

    1
   / \
  2   3
   \   \
    4   5

Consider the TypeScript code:
console.log(leftSideView(root));

medium

A. [1, 2, 4]

B. [1, 3, 5]

C. [1, 2, 5]

D. [1, 4, 5]

Solution

1. Step 1: Identify nodes visible from left at each level

   Level 1: Node 1 is visible.
   Level 2: Node 2 is the leftmost node.
   Level 3: Node 4 is visible from left (child of 2).

2. Step 2: Collect visible nodes in order

   The left side view nodes are [1, 2, 4].

3. Final Answer:

   [1, 2, 4] -> Option A

4. Quick Check:

   Left side nodes = [1, 2, 4] [OK]

Hint: Pick first node at each level from left [OK]

Common Mistakes:

• Choosing right child nodes instead of left
• Including nodes not visible from left
• Confusing order of nodes

4. The following TypeScript code attempts to find the left side view of a binary tree but has a bug. What is the bug?

function leftSideView(root: TreeNode | null): number[] {
  const result: number[] = [];
  function dfs(node: TreeNode | null, level: number) {
    if (!node) return;
    if (result.length === level) {
      result.push(node.val);
    }
    dfs(node.right, level + 1);
    dfs(node.left, level + 1);
  }
  dfs(root, 0);
  return result;
}

medium

A. The result array is not initialized

B. The base case is missing to stop recursion

C. The function visits right child before left, so left side nodes are missed

D. The function does not return any value

Solution

1. Step 1: Analyze traversal order

   The code visits the right child before the left child, so it records right side nodes first.

2. Step 2: Understand impact on left side view

   Because right nodes are visited first, left side nodes at each level may be skipped, causing incorrect output.

3. Final Answer:

   The function visits right child before left, so left side nodes are missed -> Option C

4. Quick Check:

   Visit left child first for correct left side view [OK]

Hint: Traverse left child before right to capture left side nodes [OK]

Common Mistakes:

• Visiting right child before left child
• Forgetting base case (though present here)
• Not pushing node values at correct level

5. You want to find the left side view of a binary tree but only have the tree nodes stored in a nested object format without parent references. Which approach is best to implement in TypeScript to get the left side view efficiently?

hard

A. Use level order traversal (BFS) and pick the first node at each level

B. Use in-order traversal and collect nodes in an array

C. Use post-order traversal and reverse the result array

D. Use a stack to perform iterative right-to-left traversal

Solution

1. Step 1: Understand traversal types and their suitability

   Level order traversal (BFS) visits nodes level by level, making it easy to pick the first node at each level.

2. Step 2: Evaluate other traversal methods

   In-order and post-order traversals do not guarantee level-wise order. Right-to-left iterative traversal misses left side nodes.

3. Final Answer:

   Use level order traversal (BFS) and pick the first node at each level -> Option A

4. Quick Check:

   BFS level order = best for left side view [OK]

Hint: Use BFS and select first node per level for left side view [OK]

Common Mistakes:

• Using in-order or post-order which don't give level order
• Traversing right to left instead of left to right
• Ignoring level boundaries in traversal