Print leaf nodes in binary tree from left to right using one stack

Last Updated : 06 Aug, 2021

Given a binary tree, the task is to print all leaf nodes of the given binary tree from left to right. That is, the nodes should be printed in the order they appear from left to right in the given tree.
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 the iterative approach using two stacks.
Approach:The idea is to perform iterative postorder traversal using one stack and print the leaf nodes.
Below is the implementation of the above approach:

C++

// C++ program to print leaf nodes from
// left to right 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 printLeafLeftToRight(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->left;
        }

        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
                // right subtree as null then pop that node and
                // print the node only if its left
                // subtree is also null
                if (s.top()->right == NULL) {
                    p = s.top();
                    s.pop();

                    // Print the leaf node
                    if (p->left == NULL)
                        printf("%d ", p->data);
                }

                while (p == s.top()->right) {
                    p = s.top();
                    s.pop();

                    if (s.empty())
                        break;
                }

                // If stack is not empty then assign p as
                // the stack's top node's right child
                if (!s.empty())
                    p = s.top()->right;
                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);

    printLeafLeftToRight(root);

    return 0;
}

Java

// Java program to print leaf nodes from 
// left to{ right using one stack 
import java.util.*;
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 = null;
    node.right = null; 
    node.data = key; 
    return node; 
} 

// Function to Print all the leaf nodes 
// of Binary tree using one stack 
static void printLeafLeftToRight(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.left; 
        } 

        else
        { 
            // If stack is empty then come out 
            // of the loop 
            if (s.isEmpty()) 
                break; 
            else 
            { 
                // If the node on top of the stack has its 
                // right subtree as null then pop that node and 
                // print the node only if its left 
                // subtree is also null 
                if (s.peek().right == null) 
                { 
                    p = s.peek(); 
                    s.pop(); 

                    // Print the leaf node 
                    if (p.left == null) 
                        System.out.print(p.data + " "); 
                } 

                while (p == s.peek().right) 
                { 
                    p = s.peek(); 
                    s.pop(); 

                    if (s.isEmpty()) 
                        break; 
                } 

                // If stack is not empty then assign p as 
                // the stack's top node's right child 
                if (!s.isEmpty()) 
                    p = s.peek().right; 
                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); 

    printLeafLeftToRight(root); 
} 
} 

// This code is contributed by Prerna Saini

Python3

# Python3 program to print leaf nodes from
# left to right using one stack

# Binary tree node 
class newNode: 
    
    def __init__(self, data): 
        self.data = data 
        self.left = None
        self.right = None

# Function to Print all the leaf nodes
# of Binary tree using one stack
def printLeafLeftToRight(p):
    
    # stack to store the nodes
    s = []
    while (1):
        
        # If p is not None then push
        # it on the stack
        if (p):
            s.insert(0, p)
            p = p.left
        
        else:
            
            # If stack is empty then come out
            # of the loop
            if len(s) == 0:
                break
            
            else:
                
                # If the node on top of the stack has its
                # right subtree as None then pop that node 
                # and print the node only if its left
                # subtree is also None
                if (s[0].right == None):
                    p = s[0]
                    s.pop(0)
                    
                    # Print the leaf node
                    if (p.left == None):
                        print(p.data, end = " ")
                
                while (p == s[0].right):
                    p = s[0]
                    s.pop(0)
                    
                    if len(s) == 0:
                        break
                
                # If stack is not empty then assign p as
                # the stack's top node's right child
                if len(s):
                    p = s[0].right
                
                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)

printLeafLeftToRight(root)

# This code is contributed by SHUBHAMSINGH10

// C# program to print leaf nodes from 
// left to{ right 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 = null;
    node.right = null; 
    node.data = key; 
    return node; 
} 

// Function to Print all the leaf nodes 
// of Binary tree using one stack 
static void printLeafLeftToRight(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.left; 
        } 

        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 
                // right subtree as null then pop that node and 
                // print the node only if its left 
                // subtree is also null 
                if (s.Peek().right == null) 
                { 
                    p = s.Peek(); 
                    s.Pop(); 

                    // Print the leaf node 
                    if (p.left == null) 
                        Console.Write(p.data + " "); 
                } 

                while (p == s.Peek().right) 
                { 
                    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 right child 
                if (s.Count != 0) 
                    p = s.Peek().right; 
                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); 

    printLeafLeftToRight(root); 
} 
}

// This code has been contributed by 29AjayKumar

JavaScript

<script>

    // JavaScript program to print leaf nodes from 
    // left to{ right using one stack 
    
    // Structure of binary tree
    class Node
    {
        constructor(key) {
           this.left = null;
           this.right = null;
           this.data = key;
        }
    }
    
    // Function to create a new node 
    function newNode(key) 
    { 
        let node = new Node(key); 
        return node; 
    } 

    // Function to Print all the leaf nodes 
    // of Binary tree using one stack 
    function printLeafLeftToRight(p) 
    { 
        // stack to store the nodes 
        let s = []; 

        while (true) 
        { 
            // If p is not null then push 
            // it on the stack 
            if (p != null) 
            { 
                s.push(p); 
                p = p.left; 
            } 

            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 
                    // right subtree as null then pop that node and 
                    // print the node only if its left 
                    // subtree is also null 
                    if (s[s.length - 1].right == null) 
                    { 
                        p = s[s.length - 1]; 
                        s.pop(); 

                        // Print the leaf node 
                        if (p.left == null) 
                            document.write(p.data + " "); 
                    } 

                    while (p == s[s.length - 1].right) 
                    { 
                        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 right child 
                    if (s.length != 0) 
                        p = s[s.length - 1].right; 
                    else
                        p = null; 
                } 
            } 
        } 
    } 
    
    let 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); 
  
    printLeafLeftToRight(root); 
    
</script>

Output:

4 5 6 7

Time Complexity: O(N)
Auxiliary Space: O(N)

Print nodes in top view of Binary Tree | Set 2

sakshi_srivastava

Improve

Article Tags :

Practice Tags :

Print leaf nodes in binary tree from left to right using one stack

Similar Reads

Thank You!

What kind of Experience do you want to share?