Print root to leaf paths without using recursion in C++ Programming.

Given the binary tree the program must find out the multiple paths from the root to a leaf which means all the paths should be printed but the challenge is to without using recursion.

We will traverse the tree iteratively as the constraint is to do it without recursion. So to achieve this we can use an STL map that will store the root element and whenever the leaf node is identified through level order traversal it will print the path from root to leaf as there is a map pointer which is pointing to a root node.

In the above tree, there are multiple paths which can be generated for reaching from root to leaf −

10 -> 3 -> 140
10 -> 3 -> 162
10 -> 211 -> 100
10 -> 211 -> 146

Hence, the program must print all the given paths as an output of the given binary tree.


Step 1 -> create a structure of a node as
   struct Node
      struct node *left, *right
      int data
Step 2 -> function to create a node
   node* newnode(int data)
   node->data = data
   node->left = node->right = NULL;
   return (node)
Step 3 -> create function to calculate the path
   void calculatePath(Node* curr, map<Node*, Node*> first)
   create STL stack<Node*> stk
   Loop While (curr)
      curr = first[curr]
   Loop While !stk.empty()
      curr =
      print curr->data
Step 4 -> create function to find the leaf nodes
   void leaf(Node* root)
   IF root = NULL
   Create STL stack<Node*> stc
   Create STL map<Node*, Node*> prnt
   prnt[root] = NULL
   Loop while !stc.empty()
      Node* curr =
      IF!(curr->left) && !(curr->right)
         calculatePath(curr, prnt)
      IF curr->right
         prnt[curr->right] = curr
      IF curr->left
         prnt[curr->left] = curr


 Live Demo

#include <bits/stdc++.h>
using namespace std;
//structure of a node
struct Node{
   int data;
   struct Node *left, *right;
//function to create a new node
Node* newNode(int data){
   Node* node = new Node;
   node->data = data;
   node->left = node->right = NULL;
   return node;
//this function will calculate the path
void calculatePath(Node* curr, map<Node*, Node*> first){
   stack<Node*> stk;
   while (curr){
      curr = first[curr];
   while (!stk.empty()){
      curr =;
      cout << curr->data << " ";
   cout << endl;
//this function will lead to the leafs
void leaf(Node* root){
   if (root == NULL)
   stack<Node*> stc;
   map<Node*, Node*> prnt;
   prnt[root] = NULL;
   while (!stc.empty()){
      Node* curr =;
      if (!(curr->left) && !(curr->right))
         calculatePath(curr, prnt);
      if (curr->right){
         prnt[curr->right] = curr;
      if (curr->left){
         prnt[curr->left] = curr;
int main(){
   Node* root = newNode(67); //it will insert the nodes to create a tree
   root->left = newNode(34);
   root->right = newNode(89);
   root->left->left = newNode(23);
   root->left->right = newNode(95);
   root->right->left = newNode(12);
   leaf(root); //call the function leaf
   return 0;


if we run the above program then it will generate the following output

67 34 23
67 34 95
67 89 12