Left View of a Binary Tree (original) (raw)

Last Updated : 7 Oct, 2025

Given the **root of a binary tree, Find its left view.

The left view of a binary tree is the set of nodes visible when the tree is viewed from the left side.

• It contains the **leftmost node at each level, starting from the root (top level) down to the deepest level.
• Return the nodes in order from the top level to the bottom level.

**Examples

**Input:

**Output: [1, 2, 4, 7]
**Explanation: From the left side of the tree, only the nodes 1, 2, 4 and 7 are visible.

**Input:

**Output: [1, 2, 4, 5]
**Explanation: The first node from each level will be the part of left view of tree.

Try It Yourself

Table of Content

• [Approach - 1] Using Depth-first search (DFS) - O(n) Time and O(n) Space
• [Approach - 2] Using Level Order Traversal (BFS) - O(n) Time and O(n) Space

[Approach - 1] Using Depth-first search (DFS) - O(n) Time and O(n) Space

The idea is to use DFS and Keep track of current level. For every level of the binary tree, the first node we see from the left side is part of the left view.

C++ `

#include #include using namespace std;

// Node Structure class Node { public: int data; Node* left; Node* right;

Node(int x) {
    data = x;
    left = right = nullptr;
}

};

// Recursive function to find left view void recLeftView(Node* root, int level, vector& result) { if (root == nullptr) return;

// first node of current level
if (level == result.size()) {
    result.push_back(root->data);
}

recLeftView(root->left, level + 1, result);
recLeftView(root->right, level + 1, result);

}

// Function which return left view of binary tree vector leftView(Node* root) { vector result; recLeftView(root, 0, result); return result; }

int main() { // Create binary tree

//    1
//   / \
//  2   3
//     /
//    4
//     \
//      5

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

vector<int> view = leftView(root);
for (int val : view)
    cout << val << " ";

}

Java

import java.util.ArrayList;

// Node Structure class Node { int data; Node left, right;

Node(int x) {
    data = x;
    left = right = null;
}

}

class GFG {

// Recursive function to find left view
static void recLeftView(Node root, int level, ArrayList<Integer> result) {
    if (root == null) return;
    
    // first node of current level
    if (level == result.size()) {
        result.add(root.data);
    }
    
    recLeftView(root.left, level + 1, result);
    recLeftView(root.right, level + 1, result);
}

// Function which return left view of binary tree
static ArrayList<Integer> leftView(Node root) {
    ArrayList<Integer> result = new ArrayList<>();
    recLeftView(root, 0, result);
    return result;
}

public static void main(String[] args) {
  
    // Create binary tree
    //    1
    //   / \
    //  2   3
    //     /
    //    4
    //     \
    //      5

    Node root = new Node(1);
    root.left = new Node(2);
    root.right = new Node(3);
    root.right.left = new Node(4);
    root.right.left.right = new Node(5);

    ArrayList<Integer> view = leftView(root);
    for (int val : view) 
        System.out.print(val + " ");

}

}

Python

Node Structure

class Node: def init(self, x): self.data = x self.left = None self.right = None

Recursive function to find left view

def recLeftView(root, level, result): if root is None: return

# first node of current level
if level == len(result):
    result.append(root.data)

recLeftView(root.left, level + 1, result)
recLeftView(root.right, level + 1, result)

Function which return left view of binary tree

def leftView(root): result = [] recLeftView(root, 0, result) return result

if name == "main": # Create binary tree # 1 # /
# 2 3 # / # 4 #
# 5

root = Node(1)
root.left = Node(2)
root.right = Node(3)
root.right.left = Node(4)
root.right.left.right = Node(5)

result = leftView(root)
print(*result);

C#

using System; using System.Collections.Generic;

// Node Structure class Node { public int data; public Node left, right;

public Node(int x) {
    data = x;
    left = right = null;
}

}

class GFG {

// Recursive function to find left view
static void recLeftView(Node root, int level, List<int> result) {
    if (root == null) return;
    
    // first node of current level
    if (level == result.Count) {
        result.Add(root.data);
    }
    
    recLeftView(root.left, level + 1, result);
    recLeftView(root.right, level + 1, result);
}

// Function which return left view of binary tree
static List<int> leftView(Node root) {
    List<int> result = new List<int>();
    recLeftView(root, 0, result);
    return result;
}

static void Main(string[] args) {
    // Create binary tree
    
    //    1
    //   / \
    //  2   3
    //     /
    //    4
    //     \
    //      5
    
    Node root = new Node(1);
    root.left = new Node(2);
    root.right = new Node(3);
    root.right.left = new Node(4);
    root.right.left.right = new Node(5);

    List<int> view = leftView(root);
    foreach (int val in view) {
        Console.Write(val + " ");
    }
}

}

JavaScript

// Node Structure class Node { constructor(x) { this.data = x; this.left = null; this.right = null; } }

// Recursive function to find left view function recLeftView(root, level, result) { if (root === null) return;

    // first node of current level
if (level === result.length) {
    result.push(root.data);
}

recLeftView(root.left, level + 1, result);
recLeftView(root.right, level + 1, result);

}

// Function which return left view of binary tree function leftView(root) { const result = []; recLeftView(root, 0, result); return result; }

// Driver Code

// Create binary tree // 1 // /
// 2 3 // / // 4 //
// 5

const root = new Node(1); root.left = new Node(2); root.right = new Node(3); root.right.left = new Node(4); root.right.left.right = new Node(5);

const result = leftView(root); console.log(...result);

`

[Approach - 2] Using Level Order Traversal (BFS) - O(n) Time and O(n) Space

The left view contains all nodes that are the first nodes in their levels. A simple solution is to do level order traversal and print the first nodein every level.

C++ `

#include #include #include

using namespace std;

// Node Structure class Node { public: int data; Node* left; Node* right;

Node(int x) {
    data = x;
    left = right = nullptr;
}

};

vector leftView(Node* root) { if (root == nullptr) return {};

// Queue for level order traversal
queue<Node*> q;
vector<int> res;
q.push(root);

while (!q.empty()) {
    int levelSize = q.size();

    for (int i = 0; i < levelSize; i++) {
        Node* curr = q.front();
        q.pop();

        // If it's the first node of the current level
        if (i == 0)
            res.push_back(curr->data);

        if (curr->left != nullptr)
            q.push(curr->left);
        if (curr->right != nullptr)
            q.push(curr->right);
    }
}
return res;

}

int main() { // Create binary tree // 1 // /
// 2 3 // / // 4 //
// 5 Node* root = new Node(1); root->left = new Node(2); root->right = new Node(3); root->right->left = new Node(4); root->right->left->right = new Node(5);

vector<int> res = leftView(root);
for (int node : res)
    cout << node << " ";

}

Java

import java.util.ArrayList; import java.util.Queue; import java.util.LinkedList;

// Node Structure class Node { int data; Node left, right;

Node(int x) {
    data = x;
    left = right = null;
}

}

class GFG { static ArrayList leftView(Node root) { if (root == null) return new ArrayList<>();

    // Queue for level order traversal
    Queue<Node> q = new LinkedList<>();
    ArrayList<Integer> res = new ArrayList<>();
    q.add(root);

    while (!q.isEmpty()) {
        int levelSize = q.size();

        for (int i = 0; i < levelSize; i++) {
            Node curr = q.poll();

            // If it's the first node of the current level
            if (i == 0) 
                res.add(curr.data);
            
            if (curr.left != null) {
                q.add(curr.left);
            }
            
            if (curr.right != null) {
                q.add(curr.right);
            }
        }
    }
    return res;
}

public static void main(String[] args) {
    // Create binary tree
    //    1
    //   / \
    //  2   3
    //     /
    //    4
    //     \
    //      5
    
    Node root = new Node(1);
    root.left = new Node(2);
    root.right = new Node(3);
    root.right.left = new Node(4);
    root.right.left.right = new Node(5);

    ArrayList<Integer> res = leftView(root);
    for( int node : res )
        System.out.print(node + " ");
}

}

Python

from collections import deque

Node Structure

class Node: def init(self, x): self.data = x self.left = None self.right = None

def leftView(root): if root is None: return []

# Queue for level order traversal
q = deque()
res = []
q.append(root)

while q:
    levelSize = len(q)

    for i in range(levelSize):
        curr = q.popleft()

        # If it's the first node of the current level
        if i == 0:
            res.append(curr.data)

        if curr.left:
            q.append(curr.left)
        if curr.right:
            q.append(curr.right)

return res

if name == "main" : # Create binary tree # 1 # /
# 2 3 # / # 4 #
# 5

root = Node(1)
root.left = Node(2)
root.right = Node(3)
root.right.left = Node(4)
root.right.left.right = Node(5)

res =leftView(root)
print(*res)

C#

using System; using System.Collections.Generic;

// Node Structure class Node { public int data; public Node left, right;

public Node(int x) {
    data = x;
    left = right = null;
}

}

class GFG { static List leftView(Node root) { if (root == null) return new List();

    // Queue for level order traversal
    Queue<Node> q = new Queue<Node>();
    List<int> res = new List<int>();
    q.Enqueue(root);

    while (q.Count > 0) {
        int levelSize = q.Count;

        for (int i = 0; i < levelSize; i++) {
            Node curr = q.Dequeue();

            // If it's the first node of the current level
            if (i == 0)
                res.Add(curr.data);

            if (curr.left != null) q.Enqueue(curr.left);
            if (curr.right != null) q.Enqueue(curr.right);
        }
    }
    return res;
}

static void Main(string[] args) {
    // Create binary tree
    //    1
    //   / \
    //  2   3
    //     /
    //    4
    //     \
    //      5
    
    Node root = new Node(1);
    root.left = new Node(2);
    root.right = new Node(3);
    root.right.left = new Node(4);
    root.right.left.right = new Node(5);

    List<int> res = leftView(root);
    foreach (int node in res)
        Console.Write(node + " ");
}

}

JavaScript

// Node Structure class Node { constructor(x) { this.data = x; this.left = null; this.right = null; } }

// Custom Queue Implementation class Queue { constructor() { this.items = {}; this.headIndex = 0; this.tailIndex = 0; }

enqueue(item) {
    this.items[this.tailIndex] = item;
    this.tailIndex++;
}

dequeue() {
    if (this.isEmpty()) return null;
    let item = this.items[this.headIndex];
    delete this.items[this.headIndex];
    this.headIndex++;
    return item;
}

isEmpty() {
    return this.tailIndex === this.headIndex;
}

size() {
    return this.tailIndex - this.headIndex;
}

}

function leftView(root) { if (!root) return [];

 // Queue for level order traversal
let q = new Queue();
let res = [];
q.enqueue(root);

while (!q.isEmpty()) {
    let levelSize = q.size();

    for (let i = 0; i < levelSize; i++) {
        let curr = q.dequeue();

        // If it's the first node of the current level
        if (i === 0) res.push(curr.data);

        if (curr.left) q.enqueue(curr.left);
        if (curr.right) q.enqueue(curr.right);
    }
}
return res;

}

// Driver code

// Create binary tree // 1 // /
// 2 3 // / // 4 //
// 5 let root = new Node(1); root.left = new Node(2); root.right = new Node(3); root.right.left = new Node(4); root.right.left.right = new Node(5);

let res = leftView(root); console.log(res.join(" "));

`