Left Side View of Binary Tree in DSA C

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.

      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 (as shown in ascii_picture)

Goal: Print the leftmost node at each level of the tree

Step 1: Start at root node 1, level 0, add 1 to left view

Level 0: 1 -> null

Why: Root is always visible from left side

Step 2: Go to level 1, first node is 2, add 2 to left view

Level 1: 2 -> null

Why: At level 1, leftmost node is 2

Step 3: Go to level 2, first node is 4, add 4 to left view

Level 2: 4 -> null

Why: At level 2, leftmost node is 4

Step 4: Ignore nodes 3, 5, 6 as they are not leftmost at their levels

No change to left view

Why: Only first node at each level is visible from left

Result:

1 -> 2 -> 4 -> null

Annotated Code

DSA C

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

// Define binary tree node
typedef struct Node {
    int data;
    struct Node* left;
    struct Node* right;
} Node;

// Create new node
Node* newNode(int data) {
    Node* node = (Node*)malloc(sizeof(Node));
    node->data = data;
    node->left = NULL;
    node->right = NULL;
    return node;
}

// Helper function to print left view
void leftViewUtil(Node* root, int level, int* maxLevel) {
    if (root == NULL) return;

    // If this is the first node of its level
    if (level > *maxLevel) {
        printf("%d -> ", root->data);
        *maxLevel = level;
    }

    // Traverse left subtree first to ensure leftmost nodes
    leftViewUtil(root->left, level + 1, maxLevel);
    leftViewUtil(root->right, level + 1, maxLevel);
}

// Function to print left view of binary tree
void leftView(Node* root) {
    int maxLevel = 0;
    leftViewUtil(root, 1, &maxLevel);
    printf("null\n");
}

int main() {
    // Construct the tree from dry_run input
    Node* root = newNode(1);
    root->left = newNode(2);
    root->right = newNode(3);
    root->left->left = newNode(4);
    root->left->right = newNode(5);
    root->right->right = newNode(6);

    leftView(root);
    return 0;
}

if (level > *maxLevel) {

Check if current node is first at this level to print it

printf("%d -> ", root->data);

Print the leftmost node at this level

*maxLevel = level;

Update maxLevel to mark this level as visited

leftViewUtil(root->left, level + 1, maxLevel);

Traverse left subtree first to get leftmost nodes

leftViewUtil(root->right, level + 1, maxLevel);

Traverse right subtree after left subtree

Output

1 -> 2 -> 4 -> null

Complexity Analysis

Time: O(n) because we visit every node once in the tree

Space: O(h) where h is the height of the tree due to recursion stack

vs Alternative: Compared to level order traversal using queue, this recursive approach uses less space on average and is simpler to implement

Edge Cases

Empty tree (root is NULL)

No output, function returns immediately

DSA C

if (root == NULL) return;

Tree with only root node

Prints root node as left view

DSA C

if (level > *maxLevel) {

Tree with all nodes only on right side

Prints all nodes since each is first at its level

DSA C

if (level > *maxLevel) {

When to Use This Pattern

When asked to print or find the first visible nodes from one side of a binary tree, use the left or right side view pattern by tracking levels and printing the first node encountered at each level.

Common Mistakes

Mistake: Traversing right subtree before left subtree causing wrong nodes to be printed
Fix: Always traverse left subtree before right subtree to ensure leftmost nodes are printed first

Summary

Prints the first node visible at each level when viewing the tree from the left side.

Use when you need to find or display nodes visible from the left side of a binary tree.

The key is to track levels and print the first node encountered at each level during a preorder traversal.

Practice

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

easy

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

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

C. All leaf nodes of the tree

D. Nodes at the deepest level of the tree

Solution

1. Step 1: Understand the view concept

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

2. Step 2: Differentiate from other views

   Right side view shows nodes from the right, leaf nodes are only the bottom nodes, and deepest level nodes are not necessarily visible from left.

3. Final Answer:

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

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 C code snippets correctly declares a binary tree node structure for computing the left side view?

easy

A. struct Node { int data; struct Node left; struct Node right; };

B. typedef struct Node { int data; struct Node* left; struct Node* right; } Node;

C. struct Node { int data; Node* left; Node* right; }; typedef Node;

D. typedef struct { int data; struct Node* left; struct Node* right; } Node;

Solution

1. Step 1: Check correct struct declaration

   typedef struct Node { int data; struct Node* left; struct Node* right; } Node; correctly declares a struct with pointers to left and right child nodes.

2. Step 2: Identify errors in other options

   struct Node { int data; Node* left; Node* right; }; typedef Node; misses struct keyword before Node pointers, C uses struct Node instead of pointers causing infinite size, D misses struct name for pointers.

3. Final Answer:

   typedef struct Node { int data; struct Node* left; struct Node* right; } Node; -> Option B

4. Quick Check:

   Correct struct with pointers = typedef struct Node { int data; struct Node* left; struct Node* right; } Node; [OK]

Hint: Use pointers for left and right child nodes in struct [OK]

Common Mistakes:

• Using struct members instead of pointers causing infinite size
• Missing struct keyword before pointer types
• Incorrect typedef syntax

3. Given the following binary tree:

      1
     / \
    2   3
   /     \
  4       5

What is the left side view output printed by this C code?

void leftViewUtil(Node* root, int level, int* maxLevel) {
  if (!root) return;
  if (level > *maxLevel) {
    printf("%d ", root->data);
    *maxLevel = level;
  }
  leftViewUtil(root->left, level + 1, maxLevel);
  leftViewUtil(root->right, level + 1, maxLevel);
}

void leftView(Node* root) {
  int maxLevel = 0;
  leftViewUtil(root, 1, &maxLevel);
}

medium

A. 1 3 5

B. 1 2 5

C. 1 2 4

D. 1 4 5

Solution

1. Step 1: Trace recursive calls and printing

   At level 1, print 1; level 2, print 2 (left child); level 3, print 4 (left child of 2). Right children at same levels are ignored since maxLevel is updated.

2. Step 2: Confirm output sequence

   Printed nodes are 1, 2, 4 in order with spaces.

3. Final Answer:

   1 2 4 -> Option C

4. Quick Check:

   Left side view nodes = 1 2 4 [OK]

Hint: Print first node at each level during preorder left-first traversal [OK]

Common Mistakes:

• Printing right child nodes before left
• Not updating maxLevel correctly
• Confusing left side view with right side view

4. Identify the bug in this C function intended to print the left side view of a binary tree:

void leftViewUtil(Node* root, int level, int* maxLevel) {
  if (root == NULL) return;
  if (level >= *maxLevel) {
    printf("%d ", root->data);
    *maxLevel = level;
  }
  leftViewUtil(root->left, level + 1, maxLevel);
  leftViewUtil(root->right, level + 1, maxLevel);
}

medium

A. The condition should be 'level > *maxLevel' instead of 'level >= *maxLevel'

B. The function should print after recursive calls, not before

C. The base case should check 'if (root != NULL)' instead of 'if (root == NULL)'

D. The maxLevel pointer should be passed by value, not by reference

Solution

1. Step 1: Analyze the condition for printing

   The condition 'level >= *maxLevel' causes printing nodes multiple times at the same level, which is incorrect.

2. Step 2: Correct condition usage

   It should be 'level > *maxLevel' to print only the first node encountered at each level.

3. Final Answer:

   The condition should be 'level > *maxLevel' instead of 'level >= *maxLevel' -> Option A

4. Quick Check:

   Use strict greater than for first node per level [OK]

Hint: Use '>' not '>=' to print only first node at each level [OK]

Common Mistakes:

• Using '>=' causes duplicate prints at same level
• Printing after recursion changes order
• Incorrect base case logic

5. You want to print the left side view of a binary tree using a queue for level order traversal. Which approach correctly achieves this?

1. Enqueue root
2. While queue not empty:
   a. Get number of nodes at current level (size)
   b. For i in 0 to size-1:
       - Dequeue node
       - If i == 0, print node data
       - Enqueue left child if exists
       - Enqueue right child if exists

What is the output for this tree?

      10
     /  \
    20   30
      \    \
      40    50

hard

A. 10 40 50

B. 10 30 50

C. 10 20 50

D. 10 20 40

Solution

1. Step 1: Perform level order traversal with printing first node per level

   Level 1: print 10; Level 2: print 20 (first node at level); Level 3: print 40 (first node at level).

2. Step 2: Confirm output sequence

   Nodes printed in order: 10 20 40 with spaces.

3. Final Answer:

   10 20 40 -> Option D

4. Quick Check:

   Left side view by level order = 10 20 40 [OK]

Hint: Print first node at each level during BFS traversal [OK]

Common Mistakes:

• Printing last node instead of first at each level
• Mixing left and right child enqueue order
• Not counting nodes per level correctly