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 <iostream>
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
<script>
// JavaScript program to print leaf nodes from right to left
// A Binary Tree Node
class Node
{
constructor()
{
this.data = 0;
this.right = null;
this.left = null;
}
}
// Utility function to create a new tree node
function newNode(data)
{
var temp = new Node();
temp.data = data;
temp.left = temp.right = null;
return temp;
}
// Function to print leaf
// nodes from right to left
function printLeafNodes(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)
{
document.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
var 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);
</script>
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:
- Create a stack 's' to store the nodes.
- Start from the root node and push it onto the stack.
- Traverse to the right child of the current node until it is not null, and push each node onto the stack.
- 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.
- 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.
- If the stack is empty, terminate the loop.
- 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<bits/stdc++.h>
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<Node*> 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<Node> 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<Node> s = new Stack<Node>();
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
<script>
// Javascript program to print leaf nodes from
// right to left using one stack
// Structure of binary tree
class Node
{
constructor()
{
this.left = null;
this.right = null;
this.data = 0;
}
};
// Function to create a new node
function newNode(key)
{
var 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
function printLeafRightToLeft(p)
{
// Stack to store the nodes
var s = [];
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.length == 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[s.length - 1].left == null)
{
p = s[s.length - 1];
s.pop();
// Print the leaf node
if (p.right == null)
document.write(p.data + " ");
}
while (p == s[s.length - 1].left)
{
p = s[s.length - 1];
s.pop();
if (s.length == 0)
break;
}
// If stack is not empty then assign p as
// the stack's top node's left child
if (s.length != 0)
p = s[s.length - 1].left;
else
p = null;
}
}
}
}
// Driver Code
var 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 rrrtnx
</script>
Time Complexity: O(N), where N is the total number of nodes in the binary tree.
Auxiliary Space: O(N)
Similar Reads
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 t
8 min read
Print leftmost and rightmost nodes of a Binary Tree
Given a Binary Tree, Print the corner nodes at each level. The node at the leftmost and the node at the rightmost. For example, the output for the following is 15, 10, 20, 8, 25. Recommended PracticeLeftmost and rightmost nodes of binary treeTry It! A Simple Solution is to do two traversals using th
7 min read
Print left and right leaf nodes separately in Binary Tree
Given a binary tree, the task is to print left and right leaf nodes separately. Examples: Input: 0 / \ 1 2 / \ 3 4 Output: Left Leaf Nodes: 3 Right Leaf Nodes: 4 2 Input: 0 \ 1 \ 2 \ 3 Output: Left Leaf Nodes: None Right Leaf Nodes: 3 Approach: Check if given node is null. If null, then return from
8 min read
Print Levels of all nodes in a Binary Tree
Given a Binary Tree and a key, write a function that prints levels of all keys in given binary tree. For example, consider the following tree. If the input key is 3, then your function should return 1. If the input key is 4, then your function should return 3. And for key which is not present in key
7 min read
Print alternate nodes from all levels of a Binary Tree
Given a binary tree, the task is to traverse each level of the given binary tree from left to right and print every alternate encountered at a level. Examples: Input: Output: 1 2 3 9 5 7 Input: Output: 71 88 4 6 8 10 13 Approach: The problem can be solved by performing Level Order Traversal traversa
6 min read
Print path from root to all nodes in a Complete Binary Tree
Given a number N which is the total number of nodes in a complete binary tree where nodes are number from 1 to N sequentially level-wise. The task is to write a program to print paths from root to all of the nodes in the Complete Binary Tree.For N = 3, the tree will be: 1 / \ 2 3 For N = 7, the tree
9 min read
Print all internal nodes of a Binary tree
Given a Binary tree, the task is to print all the internal nodes in a tree. An internal node is a node which carries at least one child or in other words, an internal node is not a leaf node. Here we intend to print all such internal nodes in level order. Consider the following Binary Tree: Input: O
7 min read
Print all the leaf nodes of Binary Heap
Given an array of N elements which denotes the array representation of binary heap, the task is to find the leaf nodes of this binary heap. Examples: Input: arr[] = {1, 2, 3, 4, 5, 6, 7} Output: 4 5 6 7 Explanation: 1 / \ 2 3 / \ / \ 4 5 6 7 Leaf nodes of the Binary Heap are: 4 5 6 7 Input: arr[] =
6 min read
Leaf nodes from Preorder of a Binary Search Tree
Given Preorder traversal of a Binary Search Tree. Then the task is to print leaf nodes of the Binary Search Tree from the given preorder.Examples: Input: preorder[] = [4, 2, 1, 3, 6, 5]Output: [1, 3, 5]Explaination: 1, 3 and 5 are the leaf nodes as shown in the figure. Input: preorder[] = [5, 2, 10]
14 min read
Print all even nodes of Binary Search Tree
Given a binary search tree. The task is to print all even nodes of the binary search tree. Examples: Input : 5 / \ 3 7 / \ / \ 2 4 6 8 Output : 2 4 6 8 Input : 14 / \ 12 17 / \ / \ 8 13 16 19 Output : 8 12 14 16 Approach: Traverse the Binary Search tree and check if current node's value is even. If
8 min read