# Print all leaf nodes of a binary tree from right to left

Given a binary tree, the task is to print all the leaf nodes of the binary tree from right to left.

Examples:

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

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

## Recommended: Please try your approach on {IDE} first, before moving on to the solution.

Recursive Approach: Traverse the tree in Preorder fashion, by first processing the root, then right subtree and then left subtree and do the following:

• Check if the root is null then return from the function.
• If it is a leaf node then print it.
• If not then check if it has right child, if yes then call function for right child of the node recursively.
• Check if it has left child, if yes then call function for left child of the node recursively.

Below is the implementation of the above approach:

 `// C++ program to print leaf nodes from right to left ` ` `  `#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 leaf ` `// nodes from right to left ` `void` `printLeafNodes(Node* root) ` `{ ` `    ``// If node is null, return ` `    ``if` `(!root) ` `        ``return``; ` ` `  `    ``// If node is leaf node, print its data ` `    ``if` `(!root->left && !root->right) { ` `        ``cout << root->data << ``" "``; ` `        ``return``; ` `    ``} ` ` `  `    ``// If right child exists, check for leaf ` `    ``// recursively ` `    ``if` `(root->right) ` `        ``printLeafNodes(root->right); ` ` `  `    ``// If left child exists, check for leaf ` `    ``// recursively ` `    ``if` `(root->left) ` `        ``printLeafNodes(root->left); ` `} ` ` `  `// Driver code ` `int` `main() ` `{ ` `    ``Node* root = newNode(1); ` `    ``root->left = newNode(2); ` `    ``root->right = newNode(3); ` `    ``root->left->left = newNode(4); ` `    ``root->left->right = newNode(5); ` `    ``root->right->left = newNode(6); ` `    ``root->right->right = newNode(7); ` `    ``root->left->left->left = newNode(8); ` `    ``root->right->right->left = newNode(9); ` `    ``root->left->left->left->right = newNode(10); ` ` `  `    ``printLeafNodes(root); ` ` `  `    ``return` `0; ` `} `

 `// Java program to print leaf nodes from right to left  ` `import` `java.util.*; ` ` `  `class` `GFG ` `{ ` `     `  `// A Binary Tree Node  ` `static` `class` `Node  ` `{  ` `    ``int` `data;  ` `    ``Node left, right;  ` `};  ` ` `  `// Utility function to create a new tree node  ` `static` `Node newNode(``int` `data)  ` `{  ` `    ``Node temp = ``new` `Node();  ` `    ``temp.data = data;  ` `    ``temp.left = temp.right = ``null``;  ` `    ``return` `temp;  ` `}  ` ` `  `// Function to print leaf  ` `// nodes from right to left  ` `static` `void` `printLeafNodes(Node root)  ` `{  ` `    ``// If node is null, return  ` `    ``if` `(root == ``null``)  ` `        ``return``;  ` ` `  `    ``// If node is leaf node, print its data  ` `    ``if` `(root.left == ``null` `&& root.right == ``null``)  ` `    ``{  ` `        ``System.out.print( root.data +``" "``);  ` `        ``return``;  ` `    ``}  ` ` `  `    ``// If right child exists, check for leaf  ` `    ``// recursively  ` `    ``if` `(root.right != ``null``)  ` `        ``printLeafNodes(root.right);  ` ` `  `    ``// If left child exists, check for leaf  ` `    ``// recursively  ` `    ``if` `(root.left != ``null``)  ` `        ``printLeafNodes(root.left);  ` `}  ` ` `  `// 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.left.right = newNode(``5``);  ` `    ``root.right.left = newNode(``6``);  ` `    ``root.right.right = newNode(``7``);  ` `    ``root.left.left.left = newNode(``8``);  ` `    ``root.right.right.left = newNode(``9``);  ` `    ``root.left.left.left.right = newNode(``10``);  ` ` `  `    ``printLeafNodes(root);  ` `}  ` `}  ` ` `  `// This code is contributed by Arnab Kundu `

 `# Python3 program to print  ` `# leaf nodes from right to left ` ` `  `# Binary tree node  ` `class` `newNode:  ` `     `  `    ``def` `__init__(``self``, data):  ` `        ``self``.data ``=` `data  ` `        ``self``.left ``=` `None` `        ``self``.right ``=` `None` ` `  `# Function to print leaf ` `# nodes from right to left ` `def` `printLeafNodes(root): ` `     `  `    ``# If node is null, return ` `    ``if` `root ``=``=` `None``: ` `        ``return` `     `  `    ``# If node is leaf node,  ` `    ``# print its data ` `    ``if` `(root.left ``=``=` `None` `and`  `        ``root.right ``=``=` `None``): ` `        ``print``(root.data, end ``=` `" "``) ` `        ``return` `     `  `    ``# If right child exists,  ` `    ``# check for leaf recursively ` `    ``if` `root.right: ` `        ``printLeafNodes(root.right) ` `     `  `    ``# If left child exists,  ` `    ``# check for leaf recursively ` `    ``if` `root.left: ` `        ``printLeafNodes(root.left) ` ` `  `# Driver code ` `root ``=` `newNode(``1``) ` `root.left ``=` `newNode(``2``) ` `root.right ``=` `newNode(``3``) ` `root.left.left ``=` `newNode(``4``) ` `root.left.right ``=` `newNode(``5``) ` `root.right.left ``=` `newNode(``6``) ` `root.right.right ``=` `newNode(``7``) ` `root.left.left.left ``=` `newNode(``8``) ` `root.right.right.left ``=` `newNode(``9``) ` `root.left.left.left.right ``=` `newNode(``10``) ` ` `  `printLeafNodes(root) ` ` `  `# This code is contributed by SHUBHAMSINGH10 `

 `using` `System; ` ` `  `// C# program to print leaf nodes from right to left  ` `class` `GFG ` `{ ` ` `  `// A Binary Tree Node  ` `public` `class` `Node ` `{ ` `    ``public` `int` `data; ` `    ``public` `Node left, right; ` `} ` ` `  `// Utility function to create a new tree node  ` `public` `static` `Node newNode(``int` `data) ` `{ ` `    ``Node temp = ``new` `Node(); ` `    ``temp.data = data; ` `    ``temp.left = temp.right = ``null``; ` `    ``return` `temp; ` `} ` ` `  `// Function to print leaf  ` `// nodes from right to left  ` `public` `static` `void` `printLeafNodes(Node root) ` `{ ` `    ``// If node is null, return  ` `    ``if` `(root == ``null``) ` `    ``{ ` `        ``return``; ` `    ``} ` ` `  `    ``// If node is leaf node, print its data  ` `    ``if` `(root.left == ``null` `&& root.right == ``null``) ` `    ``{ ` `        ``Console.Write(root.data + ``" "``); ` `        ``return``; ` `    ``} ` ` `  `    ``// If right child exists, check for leaf  ` `    ``// recursively  ` `    ``if` `(root.right != ``null``) ` `    ``{ ` `        ``printLeafNodes(root.right); ` `    ``} ` ` `  `    ``// If left child exists, check for leaf  ` `    ``// recursively  ` `    ``if` `(root.left != ``null``) ` `    ``{ ` `        ``printLeafNodes(root.left); ` `    ``} ` `} ` ` `  `// 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.left.right = newNode(5); ` `    ``root.right.left = newNode(6); ` `    ``root.right.right = newNode(7); ` `    ``root.left.left.left = newNode(8); ` `    ``root.right.right.left = newNode(9); ` `    ``root.left.left.left.right = newNode(10); ` ` `  `    ``printLeafNodes(root); ` `} ` `} ` ` `  `// This code is contributed by shrikanth13 `

Output:

```9 6 5 10
```

Iterative Approach: The idea is to perform iterative postorder traversal using one stack, but in a modified manner, first, we will visit the right subtree and then the left subtree and finally the root node and print the leaf nodes.

Below is the implementation of the above approach:

 `// C++ program to print leaf nodes from  ` `// right to left using one stack  ` ` `  `#include ` `using` `namespace` `std;  ` `   `  `// Structure of binary tree  ` `struct` `Node {  ` `    ``Node* left;  ` `    ``Node* right;  ` `    ``int` `data;  ` `};  ` `   `  `// Function to create a new node  ` `Node* newNode(``int` `key)  ` `{  ` `    ``Node* node = ``new` `Node();  ` `    ``node->left = node->right = NULL;  ` `    ``node->data = key;  ` `    ``return` `node;  ` `}  ` `   `  `// Function to Print all the leaf nodes  ` `// of Binary tree using one stack  ` `void` `printLeafRightToLeft(Node* p)  ` `{  ` `    ``// stack to store the nodes  ` `    ``stack s;  ` `   `  `    ``while` `(1) {  ` `        ``// If p is not null then push  ` `        ``// it on the stack  ` `        ``if` `(p) {  ` `            ``s.push(p);  ` `            ``p = p->right;  ` `        ``}  ` `   `  `        ``else` `{  ` `            ``// If stack is empty then come out  ` `            ``// of the loop  ` `            ``if` `(s.empty())  ` `                ``break``;  ` `            ``else` `{  ` `                ``// If the node on top of the stack has its  ` `                ``// left subtree as null then pop that node and  ` `                ``// print the node only if its right ` `                ``// subtree is also null  ` `                ``if` `(s.top()->left == NULL) {  ` `                    ``p = s.top();  ` `                    ``s.pop();  ` `   `  `                    ``// Print the leaf node  ` `                    ``if` `(p->right == NULL)  ` `                        ``printf``(``"%d "``, p->data);  ` `                ``}  ` `   `  `                ``while` `(p == s.top()->left) {  ` `                    ``p = s.top();  ` `                    ``s.pop();  ` `   `  `                    ``if` `(s.empty())  ` `                        ``break``;  ` `                ``}  ` `   `  `                ``// If stack is not empty then assign p as  ` `                ``// the stack's top node's left child  ` `                ``if` `(!s.empty())  ` `                    ``p = s.top()->left;  ` `                ``else` `                    ``p = NULL;  ` `            ``}  ` `        ``}  ` `    ``}  ` `}  ` `   `  `// Driver Code  ` `int` `main()  ` `{  ` `    ``Node* root = newNode(1);  ` `    ``root->left = newNode(2);  ` `    ``root->right = newNode(3);  ` `    ``root->left->left = newNode(4);  ` `    ``root->left->right = newNode(5);  ` `    ``root->right->left = newNode(6);  ` `    ``root->right->right = newNode(7);  ` `   `  `    ``printLeafRightToLeft(root);  ` `   `  `    ``return` `0;  ` `} `

 `// Java program to print leaf nodes from  ` `// right to left using one stack  ` `import` `java.util.Stack; ` ` `  `class` `GFG ` `{ ` ` `  `    ``// Structure of binary tree  ` `    ``static` `class` `Node ` `    ``{  ` `        ``Node left;  ` `        ``Node right;  ` `        ``int` `data;  ` `    ``}; ` ` `  `    ``// Function to create a new node  ` `    ``static` `Node newNode(``int` `key)  ` `    ``{  ` `        ``Node node = ``new` `Node();  ` `        ``node.left = node.right = ``null``;  ` `        ``node.data = key;  ` `        ``return` `node;  ` `    ``}  ` ` `  `    ``// Function to Print all the leaf nodes  ` `    ``// of Binary tree using one stack  ` `    ``static` `void` `printLeafRightToLeft(Node p)  ` `    ``{  ` `        ``// stack to store the nodes  ` `        ``Stack s = ``new` `Stack<>();  ` ` `  `        ``while` `(``true``)  ` `        ``{  ` `            ``// If p is not null then push  ` `            ``// it on the stack  ` `            ``if` `(p != ``null``)  ` `            ``{  ` `                ``s.push(p);  ` `                ``p = p.right;  ` `            ``}  ` ` `  `            ``else`  `            ``{  ` `                ``// If stack is empty then come out  ` `                ``// of the loop  ` `                ``if` `(s.empty())  ` `                    ``break``;  ` `                ``else` `                ``{  ` `                    ``// If the node on top of the stack has its  ` `                    ``// left subtree as null then pop that node and  ` `                    ``// print the node only if its right ` `                    ``// subtree is also null  ` `                    ``if` `(s.peek().left == ``null``)  ` `                    ``{  ` `                        ``p = s.peek();  ` `                        ``s.pop();  ` ` `  `                        ``// Print the leaf node  ` `                        ``if` `(p.right == ``null``)  ` `                            ``System.out.print( p.data+``" "``);  ` `                    ``}  ` ` `  `                    ``while` `(p == s.peek().left)  ` `                    ``{  ` `                        ``p = s.peek();  ` `                        ``s.pop();  ` ` `  `                        ``if` `(s.empty())  ` `                            ``break``;  ` `                    ``}  ` ` `  `                    ``// If stack is not empty then assign p as  ` `                    ``// the stack's top node's left child  ` `                    ``if` `(!s.empty())  ` `                        ``p = s.peek().left;  ` `                    ``else` `                        ``p = ``null``;  ` `                ``}  ` `            ``}  ` `        ``}  ` `    ``}  ` ` `  `    ``// 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.left.right = newNode(``5``);  ` `        ``root.right.left = newNode(``6``);  ` `        ``root.right.right = newNode(``7``);  ` ` `  `        ``printLeafRightToLeft(root);  ` ` `  `    ``} ` `} ` ` `  `// This code is contributed by 29AjayKumar `

 `# Python3 program to print leaf nodes   ` `# from right to left using one stack  ` ` `  `# Tree node  ` `class` `Node:  ` `    ``def` `__init__(``self``, data):  ` `        ``self``.data ``=` `data  ` `        ``self``.left ``=` `None` `        ``self``.right ``=` `None` `         `  `# Function to create a new node  ` `def` `newNode(key) : ` ` `  `    ``node ``=` `Node(``0``)  ` `    ``node.left ``=` `node.right ``=` `None` `    ``node.data ``=` `key  ` `    ``return` `node  ` ` `  `# Function to Print all the leaf nodes  ` `# of Binary tree using one stack  ` `def` `printLeafRightToLeft(p) : ` ` `  `    ``# stack to store the nodes  ` `    ``s ``=` `[]  ` ` `  `    ``while` `(``True``) : ` `         `  `        ``# If p is not None then append  ` `        ``# it on the stack  ` `        ``if` `(p !``=` `None``) : ` `            ``s.append(p)  ` `            ``p ``=` `p.right  ` `         `  `        ``else``: ` `         `  `            ``# If stack is len then come out  ` `            ``# of the loop  ` `            ``if` `(``len``(s) ``=``=` `0``) : ` `                ``break` `            ``else``: ` `             `  `                ``# If the node on top of the stack has  ` `                ``# its left subtree as None then pop   ` `                ``# that node and print the node only  ` `                ``# if its right subtree is also None  ` `                ``if` `(s[``-``1``].left ``=``=` `None``) : ` `                     `  `                    ``p ``=` `s[``-``1``]  ` `                    ``s.pop()  ` ` `  `                    ``# Print the leaf node  ` `                    ``if` `(p.right ``=``=` `None``) : ` `                        ``print``( p.data, end ``=` `" "``)  ` `                     `  `                ``while` `(p ``=``=` `s[``-``1``].left) : ` `                     `  `                    ``p ``=` `s[``-``1``]  ` `                    ``s.pop()  ` ` `  `                    ``if` `(``len``(s) ``=``=` `0``) : ` `                        ``break` `                 `  `                ``# If stack is not len then assign p as  ` `                ``# the stack's top node's left child  ` `                ``if` `(``len``(s) > ``0``) : ` `                    ``p ``=` `s[``-``1``].left  ` `                ``else``: ` `                    ``p ``=` `None` `                 `  `# Driver Code  ` `root ``=` `newNode(``1``)  ` `root.left ``=` `newNode(``2``)  ` `root.right ``=` `newNode(``3``)  ` `root.left.left ``=` `newNode(``4``)  ` `root.left.right ``=` `newNode(``5``)  ` `root.right.left ``=` `newNode(``6``)  ` `root.right.right ``=` `newNode(``7``)  ` ` `  `printLeafRightToLeft(root)  ` ` `  `# This code is contributed by Arnab Kundu `

 `// C# program to print leaf nodes from  ` `// right to left using one stack  ` `using` `System; ` `using` `System.Collections.Generic; ` ` `  `class` `GFG ` `{ ` ` `  `    ``// Structure of binary tree  ` `    ``public` `class` `Node ` `    ``{  ` `        ``public` `Node left;  ` `        ``public` `Node right;  ` `        ``public` `int` `data;  ` `    ``}; ` ` `  `    ``// Function to create a new node  ` `    ``static` `Node newNode(``int` `key)  ` `    ``{  ` `        ``Node node = ``new` `Node();  ` `        ``node.left = node.right = ``null``;  ` `        ``node.data = key;  ` `        ``return` `node;  ` `    ``}  ` ` `  `    ``// Function to Print all the leaf nodes  ` `    ``// of Binary tree using one stack  ` `    ``static` `void` `printLeafRightToLeft(Node p)  ` `    ``{  ` `        ``// stack to store the nodes  ` `        ``Stack s = ``new` `Stack();  ` ` `  `        ``while` `(``true``)  ` `        ``{  ` `            ``// If p is not null then push  ` `            ``// it on the stack  ` `            ``if` `(p != ``null``)  ` `            ``{  ` `                ``s.Push(p);  ` `                ``p = p.right;  ` `            ``}  ` ` `  `            ``else` `            ``{  ` `                ``// If stack is empty then come out  ` `                ``// of the loop  ` `                ``if` `(s.Count == 0)  ` `                    ``break``;  ` `                ``else` `                ``{  ` `                    ``// If the node on top of the stack has its  ` `                    ``// left subtree as null then pop that node and  ` `                    ``// print the node only if its right ` `                    ``// subtree is also null  ` `                    ``if` `(s.Peek().left == ``null``)  ` `                    ``{  ` `                        ``p = s.Peek();  ` `                        ``s.Pop();  ` ` `  `                        ``// Print the leaf node  ` `                        ``if` `(p.right == ``null``)  ` `                            ``Console.Write(p.data + ``" "``);  ` `                    ``}  ` ` `  `                    ``while` `(p == s.Peek().left)  ` `                    ``{  ` `                        ``p = s.Peek();  ` `                        ``s.Pop();  ` ` `  `                        ``if` `(s.Count == 0)  ` `                            ``break``;  ` `                    ``}  ` ` `  `                    ``// If stack is not empty then assign p as  ` `                    ``// the stack's top node's left child  ` `                    ``if` `(s.Count != 0)  ` `                        ``p = s.Peek().left;  ` `                    ``else` `                        ``p = ``null``;  ` `                ``}  ` `            ``}  ` `        ``}  ` `    ``}  ` ` `  `    ``// 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.left.right = newNode(5);  ` `        ``root.right.left = newNode(6);  ` `        ``root.right.right = newNode(7);  ` ` `  `        ``printLeafRightToLeft(root);  ` `    ``} ` `} ` ` `  `// This code contributed by Rajput-Ji `

Output:
```7 6 5 4
```

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.

Check out this Author's contributed articles.

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.

Article Tags :
Practice Tags :