Iterative Method To Print Left View of a Binary Tree
Given a Binary Tree, print it’s left view. Left view of a Binary Tree is a set of nodes visible when tree is seen from the left side .
Examples:
Input : 1 / \ 2 3 / \ / \ 4 5 6 7 Output : 1 2 4 Input : 1 / \ 2 3 \ / 4 5 \ 6 / \ 7 8 Output : 1 2 4 6 7
We have already discussed this problem using the Recursion method, here iterative approach is used to solve the above problem.
The idea is to do level order traversal of the Tree using a queue and print the first node at each level.
While doing level order traversal, after traversing all node at each level, push a NULL delimiter to mark the end of the current level. So, do the level order traversal of the tree. Print the first node at each level in the tree and push the children of all nodes at each level in the queue until a NULL delimiter is encountered.
Below is the implementation of above approach:
C++
// C++ program to print the // left view of Binary Tree #include <bits/stdc++.h> using namespace std; // A Binary Tree Node 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 = new node; temp->data = item; temp->left = NULL; temp->right = NULL; return temp; } // Utility function to print the left view of // the binary tree void leftViewUtil( struct node* root, queue<node*>& q) { if (root == NULL) return ; // Push root q.push(root); // Delimiter q.push(NULL); while (!q.empty()) { node* temp = q.front(); if (temp) { // Prints first node // of each level cout << temp->data << " " ; // Push children of all nodes at // current level while (q.front() != NULL) { // If left child is present // push into queue if (temp->left) q.push(temp->left); // If right child is present // push into queue if (temp->right) q.push(temp->right); // Pop the current node q.pop(); temp = q.front(); } // Push delimiter // for the next level q.push(NULL); } // Pop the delimiter of // the previous level q.pop(); } } // Function to print the leftView // of Binary Tree void leftView( struct node* root) { // Queue to store all // the nodes of the tree queue<node*> q; leftViewUtil(root, q); } // Driver Code int main() { struct node* root = newNode(10); root->left = newNode(12); root->right = newNode(3); root->left->right = newNode(4); root->right->left = newNode(5); root->right->left->right = newNode(6); root->right->left->right->left = newNode(18); root->right->left->right->right = newNode(7); leftView(root); return 0; } |
Java
// Java program to print the // left view of Binary Tree import java.util.*; class GFG { // A Binary Tree Node static class node { int data; node left, right; }; // A utility function to create a new // Binary Tree node static node newNode( int item) { node temp = new node(); temp.data = item; temp.left = null ; temp.right = null ; return temp; } static Queue<node> q; // Utility function to print the left view of // the binary tree static void leftViewUtil( node root ) { if (root == null ) return ; // add root q.add(root); // Delimiter q.add( null ); while (q.size() > 0 ) { node temp = q.peek(); if (temp != null ) { // Prints first node // of each level System.out.print(temp.data + " " ); // add children of all nodes at // current level while (q.peek() != null ) { // If left child is present // add into queue if (temp.left != null ) q.add(temp.left); // If right child is present // add into queue if (temp.right != null ) q.add(temp.right); // remove the current node q.remove(); temp = q.peek(); } // add delimiter // for the next level q.add( null ); } // remove the delimiter of // the previous level q.remove(); } } // Function to print the leftView // of Binary Tree static void leftView( node root) { // Queue to store all // the nodes of the tree q = new LinkedList<node>(); leftViewUtil(root); } // Driver Code public static void main(String args[]) { node root = newNode( 10 ); root.left = newNode( 12 ); root.right = newNode( 3 ); root.left.right = newNode( 4 ); root.right.left = newNode( 5 ); root.right.left.right = newNode( 6 ); root.right.left.right.left = newNode( 18 ); root.right.left.right.right = newNode( 7 ); leftView(root); } } // This code is contributed by Arnab Kundu |
Python3
# Python3 program to print the # 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 # Utility function to print the left # view of the binary tree def leftViewUtil(root, q) : if (root = = None ) : return # append root q.append(root) # Delimiter q.append( None ) while ( len (q)): temp = q[ 0 ] if (temp): # Prints first node of each level print (temp.data, end = " " ) # append children of all nodes # at current level while (q[ 0 ] ! = None ) : temp = q[ 0 ] # If left child is present # append into queue if (temp.left) : q.append(temp.left) # If right child is present # append into queue if (temp.right) : q.append(temp.right) # Pop the current node q.pop( 0 ) # append delimiter # for the next level q.append( None ) # Pop the delimiter of # the previous level q.pop( 0 ) # Function to print the leftView # of Binary Tree def leftView(root): # Queue to store all # the nodes of the tree q = [] leftViewUtil(root, q) # Driver Code if __name__ = = '__main__' : root = newNode( 10 ) root.left = newNode( 12 ) root.right = newNode( 3 ) root.left.right = newNode( 4 ) root.right.left = newNode( 5 ) root.right.left.right = newNode( 6 ) root.right.left.right.left = newNode( 18 ) root.right.left.right.right = newNode( 7 ) leftView(root) # This code is contributed by # Shubham Singh(SHUBHAMSINGH10) |
C#
// C# program to print the // left view of Binary Tree using System; using System.Collections.Generic; class GFG { // A Binary Tree Node public class node { public int data; public node left, right; }; // A utility function to create a new // Binary Tree node static node newNode( int item) { node temp = new node(); temp.data = item; temp.left = null ; temp.right = null ; return temp; } static Queue<node> q = new Queue<node>(); // Utility function to print the left view of // the binary tree static void leftViewUtil( node root ) { if (root == null ) return ; // add root q.Enqueue(root); // Delimiter q.Enqueue( null ); while (q.Count > 0) { node temp = q.Peek(); if (temp != null ) { // Prints first node // of each level Console.Write(temp.data + " " ); // add children of all nodes at // current level while (q.Peek() != null ) { // If left child is present // add into queue if (temp.left != null ) q.Enqueue(temp.left); // If right child is present // add into queue if (temp.right != null ) q.Enqueue(temp.right); // remove the current node q.Dequeue(); temp = q.Peek(); } // add delimiter // for the next level q.Enqueue( null ); } // remove the delimiter of // the previous level q.Dequeue(); } } // Function to print the leftView // of Binary Tree static void leftView( node root) { // Queue to store all // the nodes of the tree q = new Queue<node>(); leftViewUtil(root); } // Driver Code public static void Main(String []args) { node root = newNode(10); root.left = newNode(12); root.right = newNode(3); root.left.right = newNode(4); root.right.left = newNode(5); root.right.left.right = newNode(6); root.right.left.right.left = newNode(18); root.right.left.right.right = newNode(7); leftView(root); } } // This code is contributed by 29AjayKumar |
Javascript
<script> // JavaScript program to print the left view of Binary Tree // Binary Tree Node class node { constructor(item) { this .left = null ; this .right = null ; this .data = item; } } // A utility function to create a new // Binary Tree node function newNode(item) { let temp = new node(item); return temp; } let q = []; // Utility function to print the left view of // the binary tree function leftViewUtil(root) { if (root == null ) return ; // add root q.push(root); // Delimiter q.push( null ); while (q.length > 0) { let temp = q[0]; if (temp != null ) { // Prints first node // of each level document.write(temp.data + " " ); // add children of all nodes at // current level while (q[0] != null ) { // If left child is present // add into queue if (temp.left != null ) q.push(temp.left); // If right child is present // add into queue if (temp.right != null ) q.push(temp.right); // remove the current node q.shift(); temp = q[0]; } // add delimiter // for the next level q.push( null ); } // remove the delimiter of // the previous level q.shift(); } } // Function to print the leftView // of Binary Tree function leftView(root) { // Queue to store all // the nodes of the tree q = []; leftViewUtil(root); } let root = newNode(10); root.left = newNode(12); root.right = newNode(3); root.left.right = newNode(4); root.right.left = newNode(5); root.right.left.right = newNode(6); root.right.left.right.left = newNode(18); root.right.left.right.right = newNode(7); leftView(root); </script> |
10 12 4 6 18
Complexity Analysis:
- Time Complexity: O(N) where N is the number of vertices in the binary tree.
- Auxiliary Space: O(N).
Iterative Approach(using Stack):
To print the left view of a binary tree without using a queue, we can use an iterative approach that performs a level-order traversal of the tree and prints the first node encountered at each level. Here’s an algorithm that outlines the steps:
1) If the root is null, return.
2) Initialize a variable called “currentLevel” to 1.
3) Create a stack and push the root onto it.
4) While the stack is not empty:
a. Initialize a variable called “levelSize” to the size of the stack.
b. Initialize a boolean variable called “foundLeftMost” to false.
c. Loop through the stack from top to bottom, popping each node and pushing its children onto the stack (if they exist) in reverse order (right child first, then left child). For each node encountered, check if it is the first node encountered at its level. If so, print its value and set “foundLeftMost” to true.
d. If “foundLeftMost” is true, break out of the loop.
e. Increment “currentLevel” by 1.
5) Return.
Below is the implementation of above approach:
C++
// C++ program to print the // left view of Binary Tree #include <bits/stdc++.h> using namespace std; // Binary Tree Node struct Node { int data; struct Node* left, *right; }; // utility function to allocate // a new node with the given key struct Node* newNode( int key) { struct Node* node = new Node; node->data = key; node->left = node->right = NULL; return node; } // Utility function to print the left // view of the binary tree void print_left_view(Node* root) { if (root == NULL) return ; queue<Node*> stack; stack.push(root); while (!stack.empty()) { int levelSize = stack.size(); bool foundLeftMost = false ; for ( int i = 0; i < levelSize; i++) { Node* node = stack.front(); stack.pop(); if (!foundLeftMost) { cout << node->data << " " ; foundLeftMost = true ; } if (node->left != NULL) { stack.push(node->left); } if (node->right != NULL) { stack.push(node->right); } } } } int main() { Node* root = newNode(10); root->left = newNode(12); root->right = newNode(3); root->left->right = newNode(4); root->right->left = newNode(5); root->right->left->right = newNode(6); root->right->left->right->left = newNode(18); root->right->left->right->right = newNode(7); print_left_view(root); return 0; } |
Python3
# Python3 program to print the # 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 # Utility function to print the left # view of the binary tree def print_left_view(root): if root is None : return stack = [] stack.append(root) while stack: levelSize = len (stack) foundLeftMost = False for i in range (levelSize): node = stack.pop( 0 ) if not foundLeftMost: print (node.data) foundLeftMost = True if (node.left is not None ): stack.append(node.left) if (node.right is not None ): stack.append(node.right) if __name__ = = '__main__' : root = newNode( 10 ) root.left = newNode( 12 ) root.right = newNode( 3 ) root.left.right = newNode( 4 ) root.right.left = newNode( 5 ) root.right.left.right = newNode( 6 ) root.right.left.right.left = newNode( 18 ) root.right.left.right.right = newNode( 7 ) print_left_view(root) |
Javascript
// JavaScript program to print the // left view of Binary Tree // Binary Tree Node class Node { constructor(data) { this .data = data; this .left = null ; this .right = null ; } } // Utility function to print the left // view of the binary tree function print_left_view(root) { if (root === null ) return ; let queue = []; queue.push(root); while (queue.length !== 0) { let levelSize = queue.length; let foundLeftMost = false ; for (let i = 0; i < levelSize; i++) { let node = queue.shift(); if (!foundLeftMost) { console.log(node.data + " " ); foundLeftMost = true ; } if (node.left !== null ) { queue.push(node.left); } if (node.right !== null ) { queue.push(node.right); } } } } // Create the Binary Tree let root = new Node(10); root.left = new Node(12); root.right = new Node(3); root.left.right = new Node(4); root.right.left = new Node(5); root.right.left.right = new Node(6); root.right.left.right.left = new Node(18); root.right.left.right.right = new Node(7); // Print the left view of the Binary Tree print_left_view(root); |
10 12 4 6 18
Time Complexity: O(N) where N is the number of nodes in given binary tree.
Auxiliary Space: O(N) due to stack data structure.
Please Login to comment...