Left View of a Binary Tree Using Stack
Last Updated :
11 Jul, 2025
Given a Binary Tree, the task is to print the left view of the Binary Tree. The left view of a Binary Tree is a set of leftmost nodes for every level.
Examples:
Example 1 : The Green colored nodes represents the left view in the below Binary tree.
Example 2: The Green colored nodes represents the left view in the below Binary tree.
Approach:
The idea is to perform use stack to traverse the binary tree and track the first node encountered at each level. We can explore the tree's nodes while keeping track of their respective levels. The first node we encounter at each level will represent the left view of the tree.
Follow the steps below to solve the problem:
- If the root is null, return an empty result list.
- Create an empty list called result to store the left view nodes.
- Create a stack and push the root node along with its level (0) onto it.
- Initialize a variable , say maxLevel to track the maximum level visited (set it to -1 initially).
- While the stack is not empty, perform the following steps:
- Pop the top element from the stack, which gives us the current node and its level.
- Check if the current level is greater than maxLevel. If it is, this means we've encountered the first node at this level
- Append the node's value to the result list.
- Update maxLevel to the current level.
- To ensure left children are processed first, push the right child (if it exists) onto the stack, followed by the left child (if it exists). This way, the left child will be processed first when popping from the stack.
- After the traversal is complete, return the result list, which contains the left view of the binary tree.
Below is the implementation of above approach:
C++
// C++ program to print left view of Binary
// tree using Stack
#include <bits/stdc++.h>
using namespace std;
class Node {
public:
int data;
Node* left;
Node* right;
Node(int x) {
data = x;
left = right = nullptr;
}
};
// Function to return the left view of
// the binary tree
vector<int> leftView(Node* root) {
vector<int> result;
if (root == nullptr) return result;
// Stack for DFS traversal
stack<pair<Node*, int>> stk;
stk.push({root, 0});
// Variable to track the maximum level visited
int maxLevel = -1;
while (!stk.empty()) {
Node* curr = stk.top().first;
int level = stk.top().second;
stk.pop();
// If it's the first node of this level
if (level > maxLevel ) {
result.push_back(curr->data);
maxLevel = level;
}
// Push right child first, so left child
// is processed first
if (curr->right != nullptr) {
stk.push({curr->right, level + 1});
}
if (curr->left != nullptr) {
stk.push({curr->left, level + 1});
}
}
return result;
}
int main() {
// Representation of the input tree:
// 1
// / \
// 2 3
// / \
// 4 5
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);
vector<int> result = leftView(root);
for (int val : result) {
cout << val << " ";
}
cout << endl;
return 0;
}
// Java program to print left view of Binary
// tree using Stack
import java.util.*;
class Node {
int data;
Node left;
Node right;
Node(int x) {
data = x;
left = right = null;
}
}
class GfG {
// Function to return the left view
// of the binary tree
static ArrayList<Integer> leftView(Node root) {
ArrayList<Integer> result = new ArrayList<>();
if (root == null) return result;
// Stack for DFS traversal
Stack<Pair> s = new Stack<>();
s.push(new Pair(root, 0));
// Variable to track the maximum level visited
int maxLevel = -1;
while (!s.isEmpty()) {
Pair currPair = s.pop();
Node curr = currPair.node;
int level = currPair.level;
// If it's the first node of this level
if (level > maxLevel) {
result.add(curr.data);
maxLevel = level;
}
// Push right child first, so left child
// is processed first
if (curr.right != null) {
s.push(new Pair(curr.right, level + 1));
}
if (curr.left != null) {
s.push(new Pair(curr.left, level + 1));
}
}
return result;
}
// Helper class to hold node and level together
static class Pair {
Node node;
int level;
Pair(Node n, int l) {
node = n;
level = l;
}
}
public static void main(String[] args) {
// Representation of the input tree:
// 1
// / \
// 2 3
// / \
// 4 5
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);
List<Integer> result = leftView(root);
for (int val : result) {
System.out.print(val + " ");
}
System.out.println();
}
}
# Python program to print left view of Binary
# tree using Stack
class Node:
def __init__(self, data):
self.data = data
self.left = None
self.right = None
# Function to return the left view of the binary tree
def left_view(root):
result = []
if root is None:
return result
# Stack for DFS traversal
stack = [(root, 0)]
# Variable to track the maximum level visited
maxLevel = -1
while stack:
curr, level = stack.pop()
# If it's the first node of this level
if level > maxLevel :
result.append(curr.data)
maxLevel = level
# Push right child first, so left child is
# processed first
if curr.right:
stack.append((curr.right, level + 1))
if curr.left:
stack.append((curr.left, level + 1))
return result
if __name__ == "__main__":
# Representation of the input tree:
# 1
# / \
# 2 3
# / \
# 4 5
root = Node(1)
root.left = Node(2)
root.right = Node(3)
root.left.left = Node(4)
root.left.right = Node(5)
result = left_view(root)
for val in result:
print(val, end=" ")
print()
// C# program to print left view of Binary
// tree using Stack
using System;
using System.Collections.Generic;
class Node {
public int data;
public Node left, right;
public Node(int x) {
data = x;
left = right = null;
}
}
class GfG {
// Function to return the left view
// of the binary tree
static List<int> LeftView(Node root) {
List<int> result = new List<int>();
if (root == null) return result;
// Stack for DFS traversal
Stack<Tuple<Node, int>> stk
= new Stack<Tuple<Node, int>>();
stk.Push(new Tuple<Node, int>(root, 0));
// Variable to track the maximum level visited
int maxLevel = -1;
while (stk.Count > 0) {
Tuple<Node, int> currPair = stk.Pop();
Node curr = currPair.Item1;
int level = currPair.Item2;
// If it's the first node of this level
if (level > maxLevel) {
result.Add(curr.data);
maxLevel = level;
}
// Push right child first, so left
// child is processed first
if (curr.right != null) {
stk.Push(new Tuple<Node,
int>(curr.right, level + 1));
}
if (curr.left != null) {
stk.Push(new Tuple<Node,
int>(curr.left, level + 1));
}
}
return result;
}
static void Main(string[] args) {
// Representation of the input tree:
// 1
// / \
// 2 3
// / \
// 4 5
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);
List<int> result = LeftView(root);
foreach (int val in result) {
Console.Write(val + " ");
}
Console.WriteLine();
}
}
// JavaScript program to print left view of Binary
// tree using Stack
class Node {
constructor(data) {
this.data = data;
this.left = null;
this.right = null;
}
}
// Function to return the left view of the binary tree
function leftView(root) {
let result = [];
if (root === null) return result;
// Stack for DFS traversal
let stack = [{ node: root, level: 0 }];
// Variable to track the maximum level visited
let maxLevel = -1;
while (stack.length > 0) {
let { node, level } = stack.pop();
// If it's the first node of this level
if (level > maxLevel) {
result.push(node.data);
maxLevel = level;
}
// Push right child first, so left child
// is processed first
if (node.right !== null) {
stack.push({ node: node.right, level: level + 1 });
}
if (node.left !== null) {
stack.push({ node: node.left, level: level + 1 });
}
}
return result;
}
let 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);
let result = leftView(root);
console.log(result.join(" "));
Time Complexity: O(n), where n is the number of nodes in given binary tree.
Auxiliary Space: O(n), due to stack data structure.
Related article:
Similar Reads
Left View of a Binary Tree Given a Binary Tree, the task is to print the left view of the Binary Tree. The left view of a Binary Tree is a set of leftmost nodes for every level.Examples:Input: root[] = [1, 2, 3, 4, 5, N, N]Output: [1, 2, 4]Explanation: From the left side of the tree, only the nodes 1, 2, and 4 are visible.Inp
10 min read
Bottom View of a Binary Tree using Recursion Given a Binary Tree, the task is to print the bottom view from left to right using Recursion.Note: If there are multiple bottom-most nodes for a horizontal distance from the root, then the latter one in the level traversal is considered.Examples:Example1: The Green nodes represent the bottom view of
12 min read
Bottom View of a Binary Tree using Recursion Given a Binary Tree, the task is to print the bottom view from left to right using Recursion.Note: If there are multiple bottom-most nodes for a horizontal distance from the root, then the latter one in the level traversal is considered.Examples:Example1: The Green nodes represent the bottom view of
12 min read
Right view of Binary Tree using Queue Given a Binary Tree, the task is to print the Right view of it. The right view of a Binary Tree is a set of rightmost nodes for every level.Examples: Example 1: The Green colored nodes (1, 3, 5) represents the Right view in the below Binary tree. Example 2: The Green colored nodes (1, 3, 4, 5) repre
7 min read
Reverse alternate levels of a perfect binary tree using Stack Given a Perfect Binary Tree, the task is to reverse the alternate level nodes of the binary tree.Examples: Input: a / \ b c / \ / \ d e f g / \ / \ / \ / \ h i j k l m n o Output: Inorder Traversal of given tree h d i b j e k a l f m c n g o Inorder Traversal of modified tree o d n c m e l a k f j b
10 min read
Reverse alternate levels of a perfect binary tree using Stack Given a Perfect Binary Tree, the task is to reverse the alternate level nodes of the binary tree.Examples: Input: a / \ b c / \ / \ d e f g / \ / \ / \ / \ h i j k l m n o Output: Inorder Traversal of given tree h d i b j e k a l f m c n g o Inorder Traversal of modified tree o d n c m e l a k f j b
10 min read