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

Last Updated : 16 Mar, 2023

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```

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++

 `// 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

 `// 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

 `# 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`

## C#

 `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`

## Javascript

 ``

Output:

`9 6 5 10`

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

Space Complexity: O(h) where h is the height of binary tree due to recursion.

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.

Efficient Approach:

1. Create a stack ‘s’ to store the nodes.
2. Start from the root node and push it onto the stack.
3. Traverse to the right child of the current node until it is not null, and push each node onto the stack.
4. If the current node’s left child is null, pop the top node from the stack and check if its right child is also null, then print the value of the node.
5. If the left child of the top node on the stack is not null, then traverse to its left child and push each node onto the stack until it is not null.
6. If the stack is empty, terminate the loop.
7. Repeat steps 4 to 6 until the stack is empty.

Below is the implementation of the above approach:

## C++

 `// 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

 `// 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

 `# 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#

 `// 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`

## Javascript

 ``

Output:

`7 6 5 4`

Time Complexity: O(N), where N is the total number of nodes in the binary tree.
Auxiliary Space: O(N)

Previous
Next