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 only the family members visible from the left side, like looking at the tree from the left edge.

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

📋 What You'll Learn

Create a binary tree with the exact structure given

Use a variable to track the current level during traversal

Implement a function to find the left side view using preorder traversal

Print the left side view nodes in order

💡 Why This Matters

🌍 Real World

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

💼 Career

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

1

Create the Binary Tree Structure

Create a struct called Node with an int data, and two pointers left and right. Then create the exact binary tree with root node 1, left child 2, right child 3, left child of 2 as 4, and right child of 2 as 5.

DSA C++

// Define struct Node
// Create nodes and link them to form the tree
// Your code here

Hint

Define the Node struct with a constructor. Then create nodes and connect them exactly as described.

2

Add a Variable to Track the Current Level

Create an int variable called maxLevel and set it to 0. This will track the deepest level visited so far during traversal.

DSA C++

struct Node {
    int data;
    Node* left;
    Node* right;
    Node(int val) : data(val), left(nullptr), right(nullptr) {}
};

Node* root = new Node(1);
root->left = new Node(2);
root->right = new Node(3);
root->left->left = new Node(4);
root->left->right = new Node(5);

// Create int maxLevel and set it to 0
// Your code here

Hint

This variable helps to know if we have visited a level before.

3

Implement the Left Side View Function

Write a function called leftView that takes Node* root, int level, and a reference to int maxLevel. Use preorder traversal (visit node, then left, then right). If level is greater than maxLevel, print the node's data and update maxLevel. Then recursively call leftView for left and right children with level + 1.

DSA C++

struct Node {
    int data;
    Node* left;
    Node* right;
    Node(int val) : data(val), left(nullptr), right(nullptr) {}
};

Node* root = new Node(1);
root->left = new Node(2);
root->right = new Node(3);
root->left->left = new Node(4);
root->left->right = new Node(5);

int maxLevel = 0;

void leftView(Node* root, int level, int& maxLevel) {
    // Your code here
}

Hint

Use preorder traversal and print the node only if the current level is greater than maxLevel.

4

Print the Left Side View

Call the leftView function with root, 1 as the starting level, and maxLevel. This will print the left side view nodes.

DSA C++

struct Node {
    int data;
    Node* left;
    Node* right;
    Node(int val) : data(val), left(nullptr), right(nullptr) {}
};

Node* root = new Node(1);
root->left = new Node(2);
root->right = new Node(3);
root->left->left = new Node(4);
root->left->right = new Node(5);

int maxLevel = 0;

void leftView(Node* root, int level, int& maxLevel) {
    if (root == nullptr) {
        return;
    }
    if (level > maxLevel) {
        std::cout data left, level + 1, maxLevel);
    leftView(root->right, level + 1, maxLevel);
}

leftView(root, 1, maxLevel);

Hint

Call leftView(root, 1, maxLevel); inside main() to print the left side view.