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

06 Aug, 2021
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++
Java
Python3
C#
Javascript
// C++ program to print leaf nodes from right to left #include <iostream>using namespace std; // A Binary Tree Nodestruct Node {    int data;    struct Node *left, *right;}; // Utility function to create a new tree nodeNode* 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 leftvoid 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 codeint 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 leftimport java.util.*; class GFG{     // A Binary Tree Nodestatic class Node{    int data;    Node left, right;}; // Utility function to create a new tree nodestatic 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 leftstatic 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 codepublic 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 nodeclass newNode:         def __init__(self, data):        self.data = data        self.left = None        self.right = None # Function to print leaf# nodes from right to leftdef 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 coderoot = 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 leftclass GFG{ // A Binary Tree Nodepublic class Node{    public int data;    public Node left, right;} // Utility function to create a new tree nodepublic 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 leftpublic 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 codepublic 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 Nodeclass Node{    constructor()    {        this.data = 0;        this.right = null;        this.left = null;    }} // Utility function to create a new tree nodefunction newNode(data){    var temp = new Node();    temp.data = data;    temp.left = temp.right = null;    return temp;} // Function to print leaf// nodes from right to leftfunction 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 codevar 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>
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++
Java
Python3
C#
Javascript
// C++ program to print leaf nodes from// right to left using one stack #include<bits/stdc++.h>using namespace std;   // Structure of binary treestruct Node {    Node* left;    Node* right;    int data;};   // Function to create a new nodeNode* 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 stackvoid 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 Codeint 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 stackimport 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 nodeclass Node:    def __init__(self, data):        self.data = data        self.left = None        self.right = None         # Function to create a new nodedef 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 stackdef 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 Coderoot = 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 stackusing 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 treeclass Node{    constructor()    {        this.left = null;        this.right = null;        this.data = 0;    }}; // Function to create a new nodefunction 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 stackfunction 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 Codevar 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>
7 6 5 4
 
Time Complexity: O(N), where N is the total number of nodes in the binary tree. Auxiliary Space: O(N)
andrew1234
shrikanth13
29AjayKumar
Rajput-Ji
SHUBHAMSINGH10
rutvik_56
rrrtnx
pankajsharmagfg
Binary Tree
Data Structures
Tree
Data Structures
Tree
Writing code in comment?
Please use ide.geeksforgeeks.org,
generate link and share the link here.