Left Side View of Binary Tree in DSA Typescript - Build from Scratch

Left Side View of Binary Tree

📖 Scenario: You are working with a binary tree data structure, which is like a family tree but each parent has at most two children: left and right. You want to see the tree from the left side, so you only see the first node at each level when looking from the left.

🎯 Goal: Build a program that finds the left side view of a binary tree. This means you will print the nodes visible when the tree is seen from the left side, one node per level.

📋 What You'll Learn

Create a binary tree using a TreeNode class with val, left, and right properties.

Create a variable root representing the root node of the binary tree with exact values.

Create a variable result to store the left side view nodes.

Write a function leftSideView that takes the root node and returns an array of node values visible from the left side.

Print the result array.

💡 Why This Matters

🌍 Real World

Binary trees are used in many computer applications like organizing data, searching quickly, and representing hierarchical information such as file systems or organizational charts.

💼 Career

Understanding tree traversal and views is important for software developers working with data structures, algorithms, and system design.

1

Create the Binary Tree Structure

Create a class called TreeNode with a constructor that takes a number val and optional left and right nodes. Then create a variable called root representing this exact binary tree:

1
/ \
2 3
/ \
4 5

Use new TreeNode to create nodes with values 1, 2, 3, 4, and 5 arranged as shown.

DSA Typescript

// Define TreeNode class and create the root node with children
// Your code here

Hint

Remember to create the TreeNode class first, then build the tree from bottom to top using new TreeNode.

2

Create the Result Array

Create a variable called result and set it to an empty array of numbers. This will hold the values of the nodes visible from the left side.

DSA Typescript

class TreeNode {
    val: number;
    left: TreeNode | null;
    right: TreeNode | null;

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

const root = new TreeNode(1,
    new TreeNode(2,
        new TreeNode(4),
        null
    ),
    new TreeNode(3,
        null,
        new TreeNode(5)
    )
);

// Create an empty array called result
// Your code here

Hint

Use const result: number[] = []; to create an empty array for numbers.

3

Write the Left Side View Function

Write a function called leftSideView that takes a parameter root of type TreeNode | null and returns an array of numbers. Use a helper function inside it to do a depth-first search (DFS) that visits nodes level by level, always going left first. Add the first node you visit at each level to the result array.

DSA Typescript

class TreeNode {
    val: number;
    left: TreeNode | null;
    right: TreeNode | null;

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

const root = new TreeNode(1,
    new TreeNode(2,
        new TreeNode(4),
        null
    ),
    new TreeNode(3,
        null,
        new TreeNode(5)
    )
);

const result: number[] = [];

// Write the leftSideView function below
// Your code here

Hint

Use a helper function dfs inside leftSideView to visit nodes. Add the node value to result only if this is the first node at this level.

4

Print the Left Side View Result

Call the function leftSideView with the root node and store the result in the result variable. Then print the result array using console.log.

DSA Typescript

class TreeNode {
    val: number;
    left: TreeNode | null;
    right: TreeNode | null;

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

const root = new TreeNode(1,
    new TreeNode(2,
        new TreeNode(4),
        null
    ),
    new TreeNode(3,
        null,
        new TreeNode(5)
    )
);

const result: number[] = [];

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

// Call leftSideView with root and print the result
// Your code here

Hint

Call leftSideView(root) and print the returned array with console.log.

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