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

Left Side View of Binary Tree

📖 Scenario: Imagine you have a family tree represented as a binary tree. You want to see the names of family members visible if you look at the tree from the left side.

🎯 Goal: Build a program that shows the left side view of a binary tree by printing the nodes visible from the left side.

📋 What You'll Learn

Create a binary tree with exactly these nodes and structure:

Root node with value 1

Left child of root with value 2

Right child of root with value 3

Left child of node 2 with value 4

Right child of node 2 with value 5

Left child of node 3 with value 6

Right child of node 3 with value 7

Create a variable to track the maximum level visited

Write a function to print the left side view of the tree

Print the left side view nodes in order

💡 Why This Matters

🌍 Real World

Left side view of a binary tree helps visualize hierarchical data from a specific perspective, useful in family trees, organizational charts, and decision trees.

💼 Career

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

1

Create the binary tree nodes

Create a struct called Node with an int data and two pointers left and right. Then create nodes with values 1, 2, 3, 4, 5, 6, and 7. Connect them to form the tree with root root as described.

DSA C

// Your code here to define struct Node and create the tree nodes

Hint

Define the Node struct first. Then write a helper function newNode to create nodes. Finally, connect nodes to form the tree.

2

Add a variable to track maximum level visited

Create a global integer variable called maxLevel and set it to 0. This will help track the deepest level visited while printing the left side view.

DSA C

#include 
#include 

// Add a global variable maxLevel here

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

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

int main() {
    Node* root = newNode(1);
    root->left = newNode(2);
    root->right = newNode(3);
    root->left->left = newNode(4);
    root->left->right = newNode(5);
    root->right->left = newNode(6);
    root->right->right = newNode(7);
    return 0;
}

Hint

Declare maxLevel outside all functions so it is global.

3

Write the function to print the left side view

Write a function called printLeftView that takes a Node* called node and an int level. If node is NULL, return. If level is greater than maxLevel, print node->data and update maxLevel. Then recursively call printLeftView on node->left with level + 1, then on node->right with level + 1.

DSA C

#include 
#include 

int maxLevel = 0;

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

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

// Write printLeftView function here
// Your code here

int main() {
    Node* root = newNode(1);
    root->left = newNode(2);
    root->right = newNode(3);
    root->left->left = newNode(4);
    root->left->right = newNode(5);
    root->right->left = newNode(6);
    root->right->right = newNode(7);
    return 0;
}

Hint

Use recursion. Print the node data only if the current level is greater than maxLevel. Then update maxLevel.

4

Call the function and print the left side view

In main, call printLeftView with root and 1 as arguments. Then print a newline after the call.

DSA C

#include 
#include 

int maxLevel = 0;

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

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

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

int main() {
    Node* root = newNode(1);
    root->left = newNode(2);
    root->right = newNode(3);
    root->left->left = newNode(4);
    root->left->right = newNode(5);
    root->right->left = newNode(6);
    root->right->right = newNode(7);
    // Call printLeftView with root and 1
    // Your code here
    return 0;
}

Hint

Call printLeftView(root, 1); and then print a newline.

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