C++ प्रोग्रामिंग में प्रिंट लेवल ऑर्डर ट्रैवर्सल लाइन बाय लाइन।

बाइनरी ट्री को देखते हुए, फ़ंक्शन को एक ट्री लाइन के लेवल ऑर्डर ट्रैवर्सल को लाइन द्वारा पता लगाना चाहिए।

लेवल ऑर्डर ट्रैवर्सल:लेफ्ट रूट राइट, जिसका अर्थ है कि पहले रूट के मान से एक नोड के बाएं बच्चे को प्रिंट करें और फिर दाएं बच्चे के पास जाएं लेकिन यहां हमें लाइन से लाइन करना है जो बाएं से शुरू होगा और दाईं ओर समाप्त होगा किसी दिए गए बाइनरी ट्री का नोड.

ऊपर दिया गया बाइनरी ट्री निम्नलिखित आउटपुट उत्पन्न करेगा -

Level 0: 3
Level 1: 2 1
Level 2: 10 20 30

एल्गोरिदम

START
Step 1 -> create a structure of a node as
   struct node
      struct node *left, *right
      int data
   End
Step 2 -> function to create a node
   node* newnode(int data)
   node *temp = new node
   temp->data = data
   temp->left = temp->right= NULL
   return temp
step 3 -> function for inorder traversal
   void levelorder(node *root)
   IF root = NULL
      Return
   End
   queue<node *> que
   que.push(root)
   Loop While que.empty() = false
      int count = que.size()
      Loop While count > 0
         node *node = que.front()
         print node->data
         que.pop()
      IF node->left != NULL
         que.push(node->left)
      End
      IF node->right != NULL
         que.push(node->right)
      End
      Decrement count by 1
   End
End
Step 4 -> In main() function
   Create tree using node *root = newnode(3)
   Call levelorder(root)
STOP

उदाहरण

#include <iostream>
#include <queue>
using namespace std;
//it will create a node structure
struct node{
   struct node *left;
   int data;
   struct node *right;
};
void levelorder(node *root){
   if (root == NULL)
      return;
   queue<node *> que;
   que.push(root);
   while (que.empty() == false){
      int count = que.size();
      while (count > 0){
         node *node = que.front();
         cout << node->data << " ";
         que.pop();
         if (node->left != NULL)
            que.push(node->left);
         if (node->right != NULL)
            que.push(node->right);
         count--;
      }
   }
}
//it will create a new node
node* newnode(int data){
   node *temp = new node;
   temp->data = data;
   temp->left = NULL;
   temp->right = NULL;
   return temp;
}
int main(){
   // it will generate the binary tree
   node *root = newnode(3);
   root->left = newnode(2);
   root->right = newnode(1);
   root->left->left = newnode(10);
   root->left->right = newnode(20);
   root->right->right = newnode(30);
   levelorder(root);
   return 0;
}

आउटपुट

यदि हम उपरोक्त प्रोग्राम चलाते हैं तो यह निम्न आउटपुट उत्पन्न करेगा

3 2 1 10 20 30