Open In App

Left View of a Binary Tree Using Stack

Last Updated : 11 Jul, 2025
Comments
Improve
Suggest changes
Like Article
Like
Report

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.

Left-view-in-binary-Tree-2

Example 2: The Green colored nodes represents the left view in the below Binary tree.

Left-view-in-binary-Tree-4

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 
// 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 
# 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# 
// 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 
// 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(" "));

Output
1 2 4

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:


Next Article
Analysis of Algorithms

S
sakshi_srivastava
Improve
Article Tags :

Similar Reads

We use cookies to ensure you have the best browsing experience on our website. By using our site, you acknowledge that you have read and understood our Cookie Policy & Privacy Policy
Lightbox