 GeeksforGeeks App
Open App Browser
Continue

# Print All Leaf Nodes of a Binary Tree from left to right | Set-2 ( Iterative Approach )

Given a Binary Tree, the task is to print the leaf nodes from left to right. The nodes must be printed in the order they appear from left to right.
Examples:

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

Output :4 5 6 7

Input :
4
/  \
5    9
/ \  / \
8   3 7  2
/         / \
12        6   1

Output :12 3 7 6 1```

We have already discussed the Recursive approach. Here we will solve the problem using two stacks.
Approach:The idea is to use two stacks, one to store all the nodes of the tree and the other one to store all the leaf nodes. We will pop the top node of the first stack. If the node has a left child, we will push it on top of the first stack, if it has a right child then we will push it onto the top of the first stack, but if the node is a leaf node then we will push it onto the top of the second stack. We will do it for all the nodes until we have traversed the Binary tree completely.
Then we will start popping the second stack and print all its elements until the stack gets empty.
Below is the implementation of the above approach:

## C++

 `// C++ program to print all the leaf nodes``// of a Binary tree from left to right``#include ``using` `namespace` `std;` `// Binary tree node``struct` `Node {``    ``Node* left;``    ``Node* right;``    ``int` `data;``};` `// Function to create a new``// Binary node``Node* newNode(``int` `data)``{``    ``Node* temp = ``new` `Node;` `    ``temp->data = data;``    ``temp->left = NULL;``    ``temp->right = NULL;` `    ``return` `temp;``}` `// Function to Print all the leaf nodes``// of Binary tree using two stacks``void` `PrintLeafLeftToRight(Node* root)``{``    ``// Stack to store all the nodes of tree``    ``stack s1;` `    ``// Stack to store all the leaf nodes``    ``stack s2;` `    ``// Push the root node``    ``s1.push(root);` `    ``while` `(!s1.empty()) {``        ``Node* curr = s1.top();``        ``s1.pop();` `        ``// If current node has a left child``        ``// push it onto the first stack``        ``if` `(curr->left)``            ``s1.push(curr->left);` `        ``// If current node has a right child``        ``// push it onto the first stack``        ``if` `(curr->right)``            ``s1.push(curr->right);` `        ``// If current node is a leaf node``        ``// push it onto the second stack``        ``else` `if` `(!curr->left && !curr->right)``            ``s2.push(curr);``    ``}` `    ``// Print all the leaf nodes``    ``while` `(!s2.empty()) {``        ``cout << s2.top()->data << ``" "``;``        ``s2.pop();``    ``}``}` `// Driver code``int` `main()``{``    ``Node* root = newNode(1);``    ``root->left = newNode(2);``    ``root->right = newNode(3);``    ``root->left->left = newNode(4);``    ``root->right->left = newNode(5);``    ``root->right->right = newNode(7);``    ``root->left->left->left = newNode(10);``    ``root->left->left->right = newNode(11);``    ``root->right->right->left = newNode(8);` `    ``PrintLeafLeftToRight(root);` `    ``return` `0;``}`

## Java

 `// Java program to print all the leaf nodes``// of a Binary tree from left to right``import` `java.util.*;` `class` `GFG``{` `// Binary tree node``static` `class` `Node``{``    ``Node left;``    ``Node right;``    ``int` `data;``};` `// Function to create a new``// Binary node``static` `Node newNode(``int` `data)``{``    ``Node temp = ``new` `Node();` `    ``temp.data = data;``    ``temp.left = ``null``;``    ``temp.right = ``null``;` `    ``return` `temp;``}` `// Function to Print all the leaf nodes``// of Binary tree using two stacks``static` `void` `PrintLeafLeftToRight(Node root)``{``    ``// Stack to store all the nodes of tree``    ``Stack s1 = ``new` `Stack<>();` `    ``// Stack to store all the leaf nodes``    ``Stack s2 = ``new` `Stack<>();;` `    ``// Push the root node``    ``s1.push(root);` `    ``while` `(!s1.empty())``    ``{``        ``Node curr = s1.peek();``        ``s1.pop();` `        ``// If current node has a left child``        ``// push it onto the first stack``        ``if` `(curr.left!=``null``)``            ``s1.push(curr.left);` `        ``// If current node has a right child``        ``// push it onto the first stack``        ``if` `(curr.right!=``null``)``            ``s1.push(curr.right);` `        ``// If current node is a leaf node``        ``// push it onto the second stack``        ``else` `if` `(curr.left==``null` `&& curr.right==``null``)``            ``s2.push(curr);``    ``}` `    ``// Print all the leaf nodes``    ``while` `(!s2.empty())``    ``{``        ``System.out.print(s2.peek().data +``" "``);``        ``s2.pop();``    ``}``}` `// Driver code``public` `static` `void` `main(String[] args)``{``    ``Node root = newNode(``1``);``    ``root.left = newNode(``2``);``    ``root.right = newNode(``3``);``    ``root.left.left = newNode(``4``);``    ``root.right.left = newNode(``5``);``    ``root.right.right = newNode(``7``);``    ``root.left.left.left = newNode(``10``);``    ``root.left.left.right = newNode(``11``);``    ``root.right.right.left = newNode(``8``);` `    ``PrintLeafLeftToRight(root);``}``}` `// This code is contributed by 29AjayKumar`

## Python3

 `# Python3 program to print all the leaf``# nodes of a Binary tree from left to right` `# Binary tree node``class` `Node:``    ` `    ``def` `__init__(``self``, data):``        ``self``.data ``=` `data``        ``self``.left ``=` `None``        ``self``.right ``=` `None` `# Function to Print all the leaf nodes``# of Binary tree using two stacks``def` `PrintLeafLeftToRight(root):` `    ``# Stack to store all the nodes``    ``# of tree``    ``s1 ``=` `[]` `    ``# Stack to store all the``    ``# leaf nodes``    ``s2 ``=` `[]` `    ``# Push the root node``    ``s1.append(root)` `    ``while` `len``(s1) !``=` `0``:``        ``curr ``=` `s1.pop()` `        ``# If current node has a left child``        ``# push it onto the first stack``        ``if` `curr.left:``            ``s1.append(curr.left)` `        ``# If current node has a right child``        ``# push it onto the first stack``        ``if` `curr.right:``            ``s1.append(curr.right)` `        ``# If current node is a leaf node``        ``# push it onto the second stack``        ``elif` `not` `curr.left ``and` `not` `curr.right:``            ``s2.append(curr)``    ` `    ``# Print all the leaf nodes``    ``while` `len``(s2) !``=` `0``:``        ``print``(s2.pop().data, end ``=` `" "``)``    ` `# Driver code``if` `__name__ ``=``=` `"__main__"``:` `    ``root ``=` `Node(``1``)``    ``root.left ``=` `Node(``2``)``    ``root.right ``=` `Node(``3``)``    ``root.left.left ``=` `Node(``4``)``    ``root.right.left ``=` `Node(``5``)``    ``root.right.right ``=` `Node(``7``)``    ``root.left.left.left ``=` `Node(``10``)``    ``root.left.left.right ``=` `Node(``11``)``    ``root.right.right.left ``=` `Node(``8``)` `    ``PrintLeafLeftToRight(root)` `# This code is contributed``# by Rituraj Jain`

## C#

 `// C# program to print all the leaf nodes``// of a Binary tree from left to right``using` `System;``using` `System.Collections.Generic;` `class` `GFG``{` `// Binary tree node``public` `class` `Node``{``    ``public` `Node left;``    ``public` `Node right;``    ``public` `int` `data;``};` `// Function to create a new``// Binary node``static` `Node newNode(``int` `data)``{``    ``Node temp = ``new` `Node();` `    ``temp.data = data;``    ``temp.left = ``null``;``    ``temp.right = ``null``;` `    ``return` `temp;``}` `// Function to Print all the leaf nodes``// of Binary tree using two stacks``static` `void` `PrintLeafLeftToRight(Node root)``{``    ``// Stack to store all the nodes of tree``    ``Stack s1 = ``new` `Stack();` `    ``// Stack to store all the leaf nodes``    ``Stack s2 = ``new` `Stack();;` `    ``// Push the root node``    ``s1.Push(root);` `    ``while` `(s1.Count != 0)``    ``{``        ``Node curr = s1.Peek();``        ``s1.Pop();` `        ``// If current node has a left child``        ``// push it onto the first stack``        ``if` `(curr.left != ``null``)``            ``s1.Push(curr.left);` `        ``// If current node has a right child``        ``// push it onto the first stack``        ``if` `(curr.right != ``null``)``            ``s1.Push(curr.right);` `        ``// If current node is a leaf node``        ``// push it onto the second stack``        ``else` `if` `(curr.left == ``null` `&& curr.right == ``null``)``            ``s2.Push(curr);``    ``}` `    ``// Print all the leaf nodes``    ``while` `(s2.Count != 0)``    ``{``        ``Console.Write(s2.Peek().data + ``" "``);``        ``s2.Pop();``    ``}``}` `// Driver code``public` `static` `void` `Main(String[] args)``{``    ``Node root = newNode(1);``    ``root.left = newNode(2);``    ``root.right = newNode(3);``    ``root.left.left = newNode(4);``    ``root.right.left = newNode(5);``    ``root.right.right = newNode(7);``    ``root.left.left.left = newNode(10);``    ``root.left.left.right = newNode(11);``    ``root.right.right.left = newNode(8);` `    ``PrintLeafLeftToRight(root);``}``}` `// This code is contributed by Rajput-Ji`

## Javascript

 ``

Output:

`10 11 5 8`

Time Complexity: O(N)
Auxiliary Space: O(N)

My Personal Notes arrow_drop_up