Related Articles
Print Left View of a Binary Tree
• Difficulty Level : Medium
• Last Updated : 13 Apr, 2021

Given a Binary Tree, print left view of it. Left view of a Binary Tree is set of nodes visible when tree is visited from left side. Examples:

```Input :
1
/   \
2     3
/ \     \
4   5     6
Output : 1 2 4

Input :
1
/   \
2       3
\
4
\
5
\
6
Output :1 2 4 5 6```

Method-1 (Using Recursion)
The left view contains all nodes that are first nodes in their levels. A simple solution is to do level order traversal and print the first node in every level.
The problem can also be solved using simple recursive traversal. We can keep track of the level of a node by passing a parameter to all recursive calls. The idea is to keep track of the maximum level also. Whenever we see a node whose level is more than maximum level so far, we print the node because this is the first node in its level (Note that we traverse the left subtree before right subtree).

Below is the implementation of the above idea-

## C++

 `#include ``using` `namespace` `std;` `// Tree Node``struct` `Node {``    ``int` `data;``    ``Node* left;``    ``Node* right;``};` `vector<``int``> leftView(``struct` `Node* root);` `// Utility function to create a new Tree Node``Node* newNode(``int` `val)``{``    ``Node* temp = ``new` `Node;``    ``temp->data = val;``    ``temp->left = NULL;``    ``temp->right = NULL;` `    ``return` `temp;``}` `// Function to Build Tree``Node* buildTree(string str)``{``    ``// Corner Case``    ``if` `(str.length() == 0 || str == ``'N'``)``        ``return` `NULL;` `    ``// Creating vector of strings from input``    ``// string after spliting by space``    ``vector ip;` `    ``istringstream iss(str);``    ``for` `(string str; iss >> str;)``        ``ip.push_back(str);` `    ``// for(string i:ip)``    ``//     cout< queue;``    ``queue.push(root);` `    ``// Starting from the second element``    ``int` `i = 1;``    ``while` `(!queue.empty() && i < ip.size()) {` `        ``// Get and remove the front of the queue``        ``Node* currNode = queue.front();``        ``queue.pop();` `        ``// Get the current node's value from the string``        ``string currVal = ip[i];` `        ``// If the left child is not null``        ``if` `(currVal != ``"N"``) {` `            ``// Create the left child for the current node``            ``currNode->left = newNode(stoi(currVal));` `            ``// Push it to the queue``            ``queue.push(currNode->left);``        ``}` `        ``// For the right child``        ``i++;``        ``if` `(i >= ip.size())``            ``break``;``        ``currVal = ip[i];` `        ``// If the right child is not null``        ``if` `(currVal != ``"N"``) {` `            ``// Create the right child for the current node``            ``currNode->right = newNode(stoi(currVal));` `            ``// Push it to the queue``            ``queue.push(currNode->right);``        ``}``        ``i++;``    ``}` `    ``return` `root;``}` `int` `main()``{``    ``int` `t;``    ``scanf``(``"%d "``, &t);``    ``while` `(t--) {``        ``string s;``        ``getline(cin, s);``        ``Node* root = buildTree(s);``        ``vector<``int``> vec = leftView(root);``        ``for` `(``int` `x : vec)``            ``cout << x << ``" "``;``        ``cout << endl;``    ``}``    ``return` `0;``}`   `int` `max_level = 0;``void` `leftViewUtil(vector<``int``>& vec, Node* root, ``int` `level)``{``    ``// base case``    ``if` `(root == NULL)``        ``return``;` `    ``// If this is the first node of its level``    ``if` `(max_level < level) {``        ``vec.push_back(root->data);``        ``max_level = level;``    ``}` `    ``// Recur for left and right subtrees``    ``leftViewUtil(vec, root->left, level + 1);``    ``leftViewUtil(vec, root->right, level + 1);``}` `// Function to get the left view``vector<``int``> leftView(Node* root)``{``    ``max_level = 0; ``// initialise max_level with 0 here``    ``vector<``int``> vec;``    ``// calling util function``    ``leftViewUtil(vec, root, 1);``    ``return` `vec;``}`

## C

 `// C program to print left view of Binary Tree``#include ``#include ` `struct` `node {``    ``int` `data;``    ``struct` `node *left, *right;``};` `// A utility function to create a new Binary Tree node``struct` `node* newNode(``int` `item)``{``    ``struct` `node* temp``        ``= (``struct` `node*)``malloc``(``sizeof``(``struct` `node));``    ``temp->data = item;``    ``temp->left = temp->right = NULL;``    ``return` `temp;``}` `// Recursive function to print left view of a binary tree.``void` `leftViewUtil(``struct` `node* root, ``int` `level,``                  ``int``* max_level)``{``    ``// Base Case``    ``if` `(root == NULL)``        ``return``;` `    ``// If this is the first node of its level``    ``if` `(*max_level < level) {``        ``printf``(``"%d\t"``, root->data);``        ``*max_level = level;``    ``}` `    ``// Recur for left and right subtrees``    ``leftViewUtil(root->left, level + 1, max_level);``    ``leftViewUtil(root->right, level + 1, max_level);``}` `// A wrapper over leftViewUtil()``void` `leftView(``struct` `node* root)``{``    ``int` `max_level = 0;``    ``leftViewUtil(root, 1, &max_level);``}` `// Driver code``int` `main()``{``    ``struct` `node* root = newNode(12);``    ``root->left = newNode(10);``    ``root->right = newNode(30);``    ``root->right->left = newNode(25);``    ``root->right->right = newNode(40);` `    ``leftView(root);` `    ``return` `0;``}`

## Java

 `// Java program to print left view of binary tree` `/* Class containing left and right child of current``node and key value*/``class` `Node {``    ``int` `data;``    ``Node left, right;` `    ``public` `Node(``int` `item)``    ``{``        ``data = item;``        ``left = right = ``null``;``    ``}``}` `/* Class to print the left view */``class` `BinaryTree {``    ``Node root;``    ``static` `int` `max_level = ``0``;` `    ``// recursive function to print left view``    ``void` `leftViewUtil(Node node, ``int` `level)``    ``{``        ``// Base Case``        ``if` `(node == ``null``)``            ``return``;` `        ``// If this is the first node of its level``        ``if` `(max_level < level) {``            ``System.out.print(``" "` `+ node.data);``            ``max_level = level;``        ``}` `        ``// Recur for left and right subtrees``        ``leftViewUtil(node.left, level + ``1``);``        ``leftViewUtil(node.right, level + ``1``);``    ``}` `    ``// A wrapper over leftViewUtil()``    ``void` `leftView()``    ``{``        ``leftViewUtil(root, ``1``);``    ``}` `    ``/* testing for example nodes */``    ``public` `static` `void` `main(String args[])``    ``{``        ``/* creating a binary tree and entering the nodes */``        ``BinaryTree tree = ``new` `BinaryTree();``        ``tree.root = ``new` `Node(``12``);``        ``tree.root.left = ``new` `Node(``10``);``        ``tree.root.right = ``new` `Node(``30``);``        ``tree.root.right.left = ``new` `Node(``25``);``        ``tree.root.right.right = ``new` `Node(``40``);` `        ``tree.leftView();``    ``}``}`

## Python

 `# Python program to print left view of Binary Tree` `# A binary tree node``class` `Node:` `    ``# Constructor to create a new node``    ``def` `__init__(``self``, data):``        ``self``.data ``=` `data``        ``self``.left ``=` `None``        ``self``.right ``=` `None`  `# Recursive function pritn left view of a binary tree``def` `leftViewUtil(root, level, max_level):``    ` `    ``# Base Case``    ``if` `root ``is` `None``:``        ``return` `    ``# If this is the first node of its level``    ``if` `(max_level[``0``] < level):``        ``print` `"% d\t"` `%``(root.data),``        ``max_level[``0``] ``=` `level` `    ``# Recur for left and right subtree``    ``leftViewUtil(root.left, level ``+` `1``, max_level)``    ``leftViewUtil(root.right, level ``+` `1``, max_level)`  `# A wrapper over leftViewUtil()``def` `leftView(root):``    ``max_level ``=` `[``0``]``    ``leftViewUtil(root, ``1``, max_level)`  `# Driver program to test above function``root ``=` `Node(``12``)``root.left ``=` `Node(``10``)``root.right ``=` `Node(``20``)``root.right.left ``=` `Node(``25``)``root.right.right ``=` `Node(``40``)` `leftView(root)` `# This code is contributed by Nikhil Kumar Singh(nickzuck_007)`

## C#

 `using` `System;` `// C# program to print left view of binary tree` `/* Class containing left and right child of current``node and key value*/``public` `class` `Node {``    ``public` `int` `data;``    ``public` `Node left, right;` `    ``public` `Node(``int` `item)``    ``{``        ``data = item;``        ``left = right = ``null``;``    ``}``}` `/* Class to print the left view */``public` `class` `BinaryTree {``    ``public` `Node root;``    ``public` `static` `int` `max_level = 0;` `    ``// recursive function to print left view``    ``public` `virtual` `void` `leftViewUtil(Node node, ``int` `level)``    ``{``        ``// Base Case``        ``if` `(node == ``null``) {``            ``return``;``        ``}` `        ``// If this is the first node of its level``        ``if` `(max_level < level) {``            ``Console.Write(``" "` `+ node.data);``            ``max_level = level;``        ``}` `        ``// Recur for left and right subtrees``        ``leftViewUtil(node.left, level + 1);``        ``leftViewUtil(node.right, level + 1);``    ``}` `    ``// A wrapper over leftViewUtil()``    ``public` `virtual` `void` `leftView()``    ``{``        ``leftViewUtil(root, 1);``    ``}` `    ``/* testing for example nodes */``    ``public` `static` `void` `Main(``string``[] args)``    ``{``        ``/* creating a binary tree and entering the nodes */``        ``BinaryTree tree = ``new` `BinaryTree();``        ``tree.root = ``new` `Node(12);``        ``tree.root.left = ``new` `Node(10);``        ``tree.root.right = ``new` `Node(30);``        ``tree.root.right.left = ``new` `Node(25);``        ``tree.root.right.right = ``new` `Node(40);` `        ``tree.leftView();``    ``}``}` `// This code is contributed by Shrikant13`

Output:

`12      10      25`

Time Complexity: The function does a simple traversal of the tree, so the complexity is O(n).
Auxiliary Space: O(n), due to the stack space during recursive call.

Method-2 (Using Queue):

In this method, level order traversal based solution is discussed. If we observe carefully, we will see that our main task is to print the left most node of every level. So, we will do a level order traversal on the tree and print the leftmost node at every level. Below is the implementation of above approach:

## C++

 `// C++ program to print left view of``// Binary Tree` `#include``using` `namespace` `std;` `// A Binary Tree Node``struct` `Node``{``    ``int` `data;``    ``struct` `Node *left, *right;``};` `// Utility function to create a new tree node``Node* newNode(``int` `data)``{``    ``Node *temp = ``new` `Node;``    ``temp->data = data;``    ``temp->left = temp->right = NULL;``    ``return` `temp;``}` `// function to print left view of``// binary tree``void` `printLeftView(Node* root)``{``    ``if` `(!root)``        ``return``;` `    ``queue q;``    ``q.push(root);` `    ``while` `(!q.empty())``    ``{    ``        ``// number of nodes at current level``        ``int` `n = q.size();``        ` `        ``// Traverse all nodes of current level``        ``for``(``int` `i = 1; i <= n; i++)``        ``{``            ``Node* temp = q.front();``            ``q.pop();``                ` `            ``// Print the left most element``            ``// at the level``            ``if` `(i == 1)``                ``cout<data<<``" "``;``            ` `            ``// Add left node to queue``            ``if` `(temp->left != NULL)``                ``q.push(temp->left);` `            ``// Add right node to queue``            ``if` `(temp->right != NULL)``                ``q.push(temp->right);``        ``}``    ``}``}    ` `// Driver code``int` `main()``{``    ``// Let's construct the tree as``    ``// shown in example` `    ``Node* root = newNode(10);``    ``root->left = newNode(2);``    ``root->right = newNode(3);``    ``root->left->left = newNode(7);``    ``root->left->right = newNode(8);``    ``root->right->right = newNode(15);``    ``root->right->left = newNode(12);``    ``root->right->right->left = newNode(14);` `    ``printLeftView(root);``}` `// This code is contributed by``// Manne SreeCharan`

## Java

 `// Java program to print left view of Binary``// Tree``import` `java.util.*;` `public` `class` `PrintRightView {``    ``// Binary tree node``    ``private` `static` `class` `Node {``        ``int` `data;``        ``Node left, right;` `        ``public` `Node(``int` `data)``        ``{``            ``this``.data = data;``            ``this``.left = ``null``;``            ``this``.right = ``null``;``        ``}``    ``}` `    ``// function to print left view of binary tree``    ``private` `static` `void` `printLeftView(Node root)``    ``{``        ``if` `(root == ``null``)``            ``return``;` `        ``Queue queue = ``new` `LinkedList<>();``        ``queue.add(root);` `        ``while` `(!queue.isEmpty()) {``            ``// number of nodes at current level``            ``int` `n = queue.size();` `            ``// Traverse all nodes of current level``            ``for` `(``int` `i = ``1``; i <= n; i++) {``                ``Node temp = queue.poll();` `                ``// Print the left most element at``                ``// the level``                ``if` `(i == ``1``)``                    ``System.out.print(temp.data + ``" "``);` `                ``// Add left node to queue``                ``if` `(temp.left != ``null``)``                    ``queue.add(temp.left);` `                ``// Add right node to queue``                ``if` `(temp.right != ``null``)``                    ``queue.add(temp.right);``            ``}``        ``}``    ``}` `    ``// Driver code``    ``public` `static` `void` `main(String[] args)``    ``{``        ``// construct binary tree as shown in``        ``// above diagram``        ``Node root = ``new` `Node(``10``);``        ``root.left = ``new` `Node(``2``);``        ``root.right = ``new` `Node(``3``);``        ``root.left.left = ``new` `Node(``7``);``        ``root.left.right = ``new` `Node(``8``);``        ``root.right.right = ``new` `Node(``15``);``        ``root.right.left = ``new` `Node(``12``);``        ``root.right.right.left = ``new` `Node(``14``);` `        ``printLeftView(root);``    ``}``}` `// This code is contributed by``// Manne SreeCharan`

## Python

 `# Python3 program to print left view of``# Binary Tree` `# Binary Tree Node``""" utility that allocates a newNode``with the given key """`  `class` `newNode:` `    ``# Construct to create a newNode``    ``def` `__init__(``self``, key):``        ``self``.data ``=` `key``        ``self``.left ``=` `None``        ``self``.right ``=` `None``        ``self``.hd ``=` `0` `# function to print left view of``# binary tree`  `def` `printRightView(root):` `    ``if` `(``not` `root):``        ``return` `    ``q ``=` `[]``    ``q.append(root)` `    ``while` `(``len``(q)):` `        ``# number of nodes at current level``        ``n ``=` `len``(q)` `        ``# Traverse all nodes of current level``        ``for` `i ``in` `range``(``1``, n ``+` `1``):``            ``temp ``=` `q[``0``]``            ``q.pop(``0``)` `            ``# Print the left most element``            ``# at the level``            ``if` `(i ``=``=` `1``):``                ``print``(temp.data, end``=``" "``)` `            ``# Add left node to queue``            ``if` `(temp.left !``=` `None``):``                ``q.append(temp.left)` `            ``# Add right node to queue``            ``if` `(temp.right !``=` `None``):``                ``q.append(temp.right)`  `# Driver Code``if` `__name__ ``=``=` `'__main__'``:` `    ``root ``=` `newNode(``10``)``    ``root.left ``=` `newNode(``2``)``    ``root.right ``=` `newNode(``3``)``    ``root.left.left ``=` `newNode(``7``)``    ``root.left.right ``=` `newNode(``8``)``    ``root.right.right ``=` `newNode(``15``)``    ``root.right.left ``=` `newNode(``12``)``    ``root.right.right.left ``=` `newNode(``14``)``    ``printRightView(root)` `# This code is contributed by``# Manne SreeCharan`

## C#

 `// C# program to print left view``// of Binary Tree``using` `System;``using` `System.Collections.Generic;` `public` `class` `PrintRightView {``    ``// Binary tree node``    ``private` `class` `Node {``        ``public` `int` `data;``        ``public` `Node left, right;` `        ``public` `Node(``int` `data)``        ``{``            ``this``.data = data;``            ``this``.left = ``null``;``            ``this``.right = ``null``;``        ``}``    ``}` `    ``// function to print left view of binary tree``    ``private` `static` `void` `printRightView(Node root)``    ``{``        ``if` `(root == ``null``)``            ``return``;` `        ``Queue queue = ``new` `Queue();``        ``queue.Enqueue(root);` `        ``while` `(queue.Count != 0) {``            ``// number of nodes at current level``            ``int` `n = queue.Count;` `            ``// Traverse all nodes of current level``            ``for` `(``int` `i = 1; i <= n; i++) {``                ``Node temp = queue.Dequeue();` `                ``// Print the left most element at``                ``// the level``                ``if` `(i == n)``                    ``Console.Write(temp.data + ``" "``);` `                ``// Add left node to queue``                ``if` `(temp.left != ``null``)``                    ``queue.Enqueue(temp.left);` `                ``// Add right node to queue``                ``if` `(temp.right != ``null``)``                    ``queue.Enqueue(temp.right);``            ``}``        ``}``    ``}` `    ``// Driver code``    ``public` `static` `void` `Main(String[] args)``    ``{``        ``// construct binary tree as shown in``        ``// above diagram``        ``Node root = ``new` `Node(10);``        ``root.left = ``new` `Node(2);``        ``root.right = ``new` `Node(3);``        ``root.left.left = ``new` `Node(7);``        ``root.left.right = ``new` `Node(8);``        ``root.right.right = ``new` `Node(15);``        ``root.right.left = ``new` `Node(12);``        ``root.right.right.left = ``new` `Node(14);``        ``printRightView(root);``    ``}``}` `// This code is contributed Manne SreeCharan`
Output
`10 2 7 14 `

Time Complexity: O( n ), where n is the number of nodes in the binary tree.