GeeksforGeeks App
Open App
Browser
Continue

# Print all leaf nodes of a Binary Tree from left to right

Given a binary tree, we need to write a program 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.

For Example,

For the above binary tree, the output will be as shown below:

`4 6 7 9 10`

The idea to do this is similar to DFS algorithm. Below is a step by step algorithm to do this:

1. Check if the given node is null. If null, then return from the function.
2. Check if it is a leaf node. If the node is a leaf node, then print its data.
3. If in the above step, the node is not a leaf node then check if the left and right children of node exist. If yes then call the function for left and right child of the node recursively.

Below is the implementation of the above approach.

## C++

 `/* C++ program to print leaf nodes from left``   ``to right */``#include ``using` `namespace` `std;`` ` `// A Binary Tree Node``struct` `Node``{``    ``int` `data;``    ``struct` `Node *left, *right;``};` `// function to print leaf``// nodes from left to right``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 left child exists, check for leaf``    ``// recursively``    ``if` `(root->left)``       ``printLeafNodes(root->left);``        ` `    ``// if right child exists, check for leaf``    ``// recursively``    ``if` `(root->right)``       ``printLeafNodes(root->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;``}`` ` `// Driver program to test above functions``int` `main()``{``    ``// Let us create binary tree shown in``    ``// above diagram``    ``Node *root = newNode(1);``    ``root->left = newNode(2);``    ``root->right = newNode(3);``    ``root->left->left = newNode(4);``    ``root->right->left = newNode(5);``    ``root->right->right = newNode(8);``    ``root->right->left->left = newNode(6);``    ``root->right->left->right = newNode(7);``    ``root->right->right->left = newNode(9);``    ``root->right->right->right = newNode(10);`` ` `    ``// print leaf nodes of the given tree``    ``printLeafNodes(root);``    ` `    ``return` `0;``}`

## Java

 `// Java program to print leaf nodes``// from left to right``import` `java.util.*;``  ` `class` `GFG{``     ` `// A Binary Tree Node``static` `class` `Node``{``    ``public` `int` `data;``    ``public` `Node left, right;``};`` ` `// Function to print leaf``// nodes from left to right``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 left child exists, check for leaf``    ``// recursively``    ``if` `(root.left != ``null``)``        ``printLeafNodes(root.left);``         ` `    ``// If right child exists, check for leaf``    ``// recursively``    ``if` `(root.right != ``null``)``        ``printLeafNodes(root.right);``}`` ` `// Utility function to create a new tree node``static` `Node newNode(``int` `data)``{``    ``Node temp = ``new` `Node();``    ``temp.data = data;``    ``temp.left = ``null``;``    ``temp.right = ``null``;``    ``return` `temp;``}`` ` `// Driver code``public` `static` `void` `main(String []args)``{``     ` `    ``// Let us create binary tree shown in``    ``// above diagram``    ``Node root = newNode(``1``);``    ``root.left = newNode(``2``);``    ``root.right = newNode(``3``);``    ``root.left.left = newNode(``4``);``    ``root.right.left = newNode(``5``);``    ``root.right.right = newNode(``8``);``    ``root.right.left.left = newNode(``6``);``    ``root.right.left.right = newNode(``7``);``    ``root.right.right.left = newNode(``9``);``    ``root.right.right.right = newNode(``10``);`` ` `    ``// Print leaf nodes of the given tree``    ``printLeafNodes(root);``}``}` `// This code is contributed by pratham76`

## Python3

 `# Python3 program to print``# leaf nodes from left to right` `# Binary tree node``class` `Node:``  ` `    ``def` `__init__(``self``, data):``        ``self``.data ``=` `data``        ``self``.left ``=` `None``        ``self``.right ``=` `None` `# Function to print leaf``# nodes from left to right``def` `printLeafNodes(root: Node) ``-``> ``None``:` `    ``# If node is null, return``    ``if` `(``not` `root):``        ``return` `    ``# If node is leaf node,``    ``# print its data``    ``if` `(``not` `root.left ``and``        ``not` `root.right):``        ``print``(root.data,``              ``end ``=` `" "``)``        ``return` `    ``# If left child exists,``    ``# check for leaf recursively``    ``if` `root.left:``        ``printLeafNodes(root.left)` `    ``# If right child exists,``    ``# check for leaf recursively``    ``if` `root.right:``        ``printLeafNodes(root.right)` `# Driver Code``if` `__name__ ``=``=` `"__main__"``:` `    ``# Let us create binary tree shown in``    ``# above diagram``    ``root ``=` `Node(``1``)``    ``root.left ``=` `Node(``2``)``    ``root.right ``=` `Node(``3``)``    ``root.left.left ``=` `Node(``4``)``    ``root.right.left ``=` `Node(``5``)``    ``root.right.right ``=` `Node(``8``)``    ``root.right.left.left ``=` `Node(``6``)``    ``root.right.left.right ``=` `Node(``7``)``    ``root.right.right.left ``=` `Node(``9``)``    ``root.right.right.right ``=` `Node(``10``)` `    ``# print leaf nodes of the given tree``    ``printLeafNodes(root)` `# This code is contributed by sanjeev2552`

## C#

 `// C# program to print leaf nodes``// from left to right``using` `System;`` ` `class` `GFG{``    ` `// A Binary Tree Node``class` `Node``{``    ``public` `int` `data;``    ``public` `Node left, right;``};` `// Function to print leaf``// nodes from left to right``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 left child exists, check for leaf``    ``// recursively``    ``if` `(root.left != ``null``)``        ``printLeafNodes(root.left);``        ` `    ``// If right child exists, check for leaf``    ``// recursively``    ``if` `(root.right != ``null``)``        ``printLeafNodes(root.right);``}` `// Utility function to create a new tree node``static` `Node newNode(``int` `data)``{``    ``Node temp = ``new` `Node();``    ``temp.data = data;``    ``temp.left = ``null``;``    ``temp.right = ``null``;``    ``return` `temp;``}` `// Driver code``public` `static` `void` `Main()``{``    ` `    ``// Let us create binary tree shown in``    ``// above diagram``    ``Node root = newNode(1);``    ``root.left = newNode(2);``    ``root.right = newNode(3);``    ``root.left.left = newNode(4);``    ``root.right.left = newNode(5);``    ``root.right.right = newNode(8);``    ``root.right.left.left = newNode(6);``    ``root.right.left.right = newNode(7);``    ``root.right.right.left = newNode(9);``    ``root.right.right.right = newNode(10);` `    ``// Print leaf nodes of the given tree``    ``printLeafNodes(root);``}``}` `// This code is contributed by rutvik_56`

## Javascript

 ``

Output

`4 6 7 9 10 `

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

Iterative Method:

Following is a simple stack-based iterative method to print the leaf nodes from left to right.

• Create an empty stack ‘st’ and push the root node to stack.
• Do the following while stack is not empty.
• Pop an item from the stack
• If the node is a leaf node then print it.
• Else:
• If the right node is not NULL
• push the right node into the stack
• If the left node is not NULL
• push the left node into the stack

Below is the implementation of the above approach.

## C++

 `// C++ program to print leaf nodes from left to right``#include ``using` `namespace` `std;` `// A Binary Tree Node``struct` `Node {``    ``int` `data;``    ``struct` `Node *left, *right;``};` `// fun to creates and returns a new node``Node* newNode(``int` `data)``{``    ``Node* temp = ``new` `Node();``    ``temp->data = data;``    ``temp->left = temp->right = NULL;``    ``return` `temp;``}` `// fun to print leaf nodes from left to right``void` `printleafNodes(Node* root)``{``    ``// base case``    ``if` `(!root)``        ``return``;` `    ``// implement iterative preorder traversal and start``    ``// storing leaf nodes.``    ``stack st;``    ``st.push(root);` `    ``while` `(!st.empty()) {``        ``root = st.top();``        ``st.pop();` `        ``// if node is leafnode, print its data``        ``if` `(!root->left && !root->right)``            ``cout << root->data << ``" "``;` `        ``if` `(root->right)``            ``st.push(root->right);``        ``if` `(root->left)``            ``st.push(root->left);``    ``}``}` `// Driver program to test above functions``int` `main()``{` `    ``// create a binary tree``    ``Node* root = newNode(1);``    ``root->left = newNode(2);``    ``root->right = newNode(3);``      ``root->left->left = newNode(4);``    ``root->right->left = newNode(5);``    ``root->right->right = newNode(8);``    ``root->right->left->left = newNode(6);``    ``root->right->left->right = newNode(7);``    ``root->right->right->left = newNode(9);``    ``root->right->right->right = newNode(10);` `    ``// prints leaf nodes of the given tree``    ``printleafNodes(root);` `    ``return` `0;``}``// This Method and code is contributed by Modem Upendra`

## Java

 `// Java program to print leaf nodes from left to right``import` `java.util.*;` `public` `class` `GFG {` `    ``// structure of node of Binary Tree``    ``static` `class` `Node {``        ``int` `data;``        ``Node left, right;` `        ``Node(``int` `item)``        ``{``            ``data = item;``            ``left = right = ``null``;``        ``}``    ``}` `    ``// fun to print leaf nodes from left to right``    ``static` `void` `printleafNodes(Node root)``    ``{``        ``// base case``        ``if` `(root == ``null``)``            ``return``;` `        ``// implement iterative preorder traversal and start``        ``// storing leaf nodes.``        ``Stack st = ``new` `Stack<>();``        ``st.push(root);` `        ``while` `(!st.isEmpty()) {``            ``root = st.peek();``            ``st.pop();` `            ``// if node is leafnode, print its data``            ``if` `(root.left == ``null` `&& root.right == ``null``)``                ``System.out.print(root.data + ``" "``);` `            ``if` `(root.right != ``null``)``                ``st.push(root.right);``            ``if` `(root.left != ``null``)``                ``st.push(root.left);``        ``}``    ``}` `    ``// Driver program to test above functions``    ``public` `static` `void` `main(String[] args)``    ``{``        ``// create a binary tree``        ``Node root = ``new` `Node(``1``);``        ``root.left = ``new` `Node(``2``);``        ``root.right = ``new` `Node(``3``);``        ``root.left.left = ``new` `Node(``4``);``        ``root.right.left = ``new` `Node(``5``);``        ``root.right.right = ``new` `Node(``8``);``        ``root.right.left.left = ``new` `Node(``6``);``        ``root.right.left.right = ``new` `Node(``7``);``        ``root.right.right.left = ``new` `Node(``9``);``        ``root.right.right.right = ``new` `Node(``10``);` `        ``// prints leaf nodes of the given tree``        ``printleafNodes(root);``    ``}``}``// This code is contributed by Karandeep1234`

## Python3

 `# Python3 program to print leaf nodes from left to right` `# A Binary Tree Node``class` `Node:` `    ``def` `__init__(``self``, data):``        ``self``.data ``=` `data``        ``self``.left ``=` `None``        ``self``.right ``=` `None` `# fun to creates and returns a new node``def` `newNode(data):``    ``temp ``=` `Node(data)``    ``return` `temp` `# fun to print leaf nodes from left to right``def` `printleafNodes(root):``    ``# base case``    ``if` `not` `root:``        ``return``    ``# implement iterative preorder traversal and start``    ``# storing leaf nodes.``    ``st ``=` `[]``    ``st.append(root)` `    ``while` `len``(st) > ``0``:``        ``root ``=` `st.pop()` `        ``# if node is leafnode, print its data``        ``if` `not` `root.left ``and` `not` `root.right:``            ``print``(root.data, end``=``" "``)` `        ``if` `root.right:``            ``st.append(root.right)``        ``if` `root.left:``            ``st.append(root.left)` `# Driver program to test above functions``if` `__name__ ``=``=` `'__main__'``:` `    ``# create a binary tree``    ``root ``=` `newNode(``1``)``    ``root.left ``=` `newNode(``2``)``    ``root.right ``=` `newNode(``3``)``    ``root.left.left ``=` `newNode(``4``)``    ``root.right.left ``=` `newNode(``5``)``    ``root.right.right ``=` `newNode(``8``)``    ``root.right.left.left ``=` `newNode(``6``)``    ``root.right.left.right ``=` `newNode(``7``)``    ``root.right.right.left ``=` `newNode(``9``)``    ``root.right.right.right ``=` `newNode(``10``)` `    ``# prints leaf nodes of the given tree``    ``printleafNodes(root)` `# This code is contributed by lokeshpotta20.`

## C#

 `using` `System;``using` `System.Collections.Generic;` `class` `GFG {``  ``// structure of node of Binary Tree``  ``class` `Node {``    ``public` `int` `data;``    ``public` `Node left, right;` `    ``public` `Node(``int` `item)``    ``{``      ``data = item;``      ``left = right = ``null``;``    ``}``  ``}` `  ``// fun to print leaf nodes from left to right``  ``static` `void` `printleafNodes(Node root)``  ``{``    ``// base case``    ``if` `(root == ``null``)``      ``return``;` `    ``// implement iterative preorder traversal and start``    ``// storing leaf nodes.``    ``Stack st = ``new` `Stack();``    ``st.Push(root);` `    ``while` `(st.Count != 0) {``      ``root = st.Peek();``      ``st.Pop();` `      ``// if node is leafnode, print its data``      ``if` `(root.left == ``null` `&& root.right == ``null``)``        ``Console.Write(root.data + ``" "``);` `      ``if` `(root.right != ``null``)``        ``st.Push(root.right);``      ``if` `(root.left != ``null``)``        ``st.Push(root.left);``    ``}``  ``}` `  ``// Driver program to test above functions``  ``public` `static` `void` `Main(``string``[] args)``  ``{``    ``// create a binary tree``    ``Node root = ``new` `Node(1);``    ``root.left = ``new` `Node(2);``    ``root.right = ``new` `Node(3);``    ``root.left.left = ``new` `Node(4);``    ``root.right.left = ``new` `Node(5);``    ``root.right.right = ``new` `Node(8);``    ``root.right.left.left = ``new` `Node(6);``    ``root.right.left.right = ``new` `Node(7);``    ``root.right.right.left = ``new` `Node(9);``    ``root.right.right.right = ``new` `Node(10);` `    ``// prints leaf nodes of the given tree``    ``printleafNodes(root);``  ``}``}` `// This code is contributed by pradeepkumarppk2003`

## Javascript

 `// Javascript program to print leaf nodes from left to right` `// A Binary Tree Node``class Node {``    ``constructor(data){``        ``this``.data=data;``        ``this``.left=``null``;``        ``this``.right=``null``;``    ``}``}` `// fun to print leaf nodes from left to right``function` `printleafNodes(root)``{``    ``// base case``    ``if` `(!root)``        ``return``;` `    ``// implement iterative preorder traversal and start``    ``// storing leaf nodes.``    ``let st=[];``    ``st.push(root);` `    ``while` `(st.length>0) {``        ``root = st[st.length-1];``        ``st.pop();` `        ``// if node is leafnode, print its data``        ``if` `(!root.left && !root.right)``            ``document.write(root.data + ``" "``);` `        ``if` `(root.right)``            ``st.push(root.right);``        ``if` `(root.left)``            ``st.push(root.left);``    ``}``}` `// Driver program to test above functions``// create a binary tree``let root = ``new` `Node(1);``root.left = ``new` `Node(2);``root.right = ``new` `Node(3);``root.left.left = ``new` `Node(4);``root.right.left = ``new` `Node(5);``root.right.right = ``new` `Node(8);``root.right.left.left = ``new` `Node(6);``root.right.left.right = ``new` `Node(7);``root.right.right.left = ``new` `Node(9);``root.right.right.right = ``new` `Node(10);` `// prints leaf nodes of the given tree``printleafNodes(root);`

Output

`4 6 7 9 10 `

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

This article is contributed by Harsh Agarwal. If you like GeeksforGeeks and would like to contribute, you can also write an article using write.geeksforgeeks.org or mail your article to review-team@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

My Personal Notes arrow_drop_up