algorithm
बाइनरी ट्री ट्रैवर्सल्स

परिचय

बाइनरी ट्री का प्री-ऑर्डर, इनवर्टर और पोस्ट ऑर्डर ट्रैवर्सल

बाइनरी ट्री पर विचार करें:

प्री-ऑर्डर ट्रैवर्सल (रूट) नोड को ट्रेस कर रहा है फिर नोड के बाएं उप-पेड़ और फिर नोड के दाएं उप-पेड़।

तो उपरोक्त पेड़ का पूर्व-क्रम ट्रावेल होगा:

1 2 4 5 3 6 7

इन-ऑर्डर ट्रावर्सल (रूट) नोड के बाएं उप-पेड़ और फिर नोड के दाएं उप-ट्री को ट्रेस कर रहा है।

तो उपरोक्त पेड़ का इन-ऑर्डर ट्रावरल होगा:

4 2 5 1 6 3 7

पोस्ट-ऑर्डर ट्रैवर्सल (रूट) नोड के बाएँ उप-ट्री और फिर राइट सब-ट्री और फिर नोड से ट्रेस हो रहा है।

तो ऊपर के पेड़ के बाद के आदेश का पालन होगा:

४ ५ २ ६ 5 ३ ३ १

स्तर आदेश ट्रैवर्सल - कार्यान्वयन

उदाहरण के लिए यदि दिए गए पेड़ हैं:

लेवल ऑर्डर ट्रावेल होगा

1 2 3 4 5 6 7

नोड डेटा स्तर द्वारा मुद्रण स्तर।

कोड:

#include<iostream>
#include<queue>
#include<malloc.h>

using namespace std;

struct node{
    
    int data;
    node *left;
    node *right;
};

void levelOrder(struct node *root){
    
        if(root == NULL)    return;
        
        queue<node *> Q;
        Q.push(root);
        
        while(!Q.empty()){
        struct    node* curr = Q.front();
            cout<< curr->data <<" ";
            if(curr->left != NULL) Q.push(curr-> left);
                if(curr->right != NULL) Q.push(curr-> right);
                
                Q.pop();
            
            
        }
}
struct node* newNode(int data)
{
    struct node* node = (struct node*)
                        malloc(sizeof(struct node));
    node->data = data;
    node->left = NULL;
    node->right = NULL;
 
    return(node);
}

int main(){
    
    struct 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);
 
 
    printf("Level Order traversal of binary tree is \n");
    levelOrder(root);
    
    return 0;
    
    
}

उपरोक्त उद्देश्य को प्राप्त करने के लिए कतार डेटा संरचना का उपयोग किया जाता है।