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

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

filter_none

edit
close

play_arrow

link
brightness_4
code

// 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;
}

chevron_right


Java

filter_none

edit
close

play_arrow

link
brightness_4
code

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

chevron_right


Python3

filter_none

edit
close

play_arrow

link
brightness_4
code

# 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

chevron_right


C#

filter_none

edit
close

play_arrow

link
brightness_4
code

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

chevron_right


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

filter_none

edit
close

play_arrow

link
brightness_4
code

// 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; 
}

chevron_right


Java

filter_none

edit
close

play_arrow

link
brightness_4
code

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

chevron_right


C#

filter_none

edit
close

play_arrow

link
brightness_4
code

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

chevron_right


Output:

7 6 5 4


My Personal Notes arrow_drop_up

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.