C++ प्रोग्राम: लिंक्ड लिस्ट का उपयोग करके बाइनरी सर्च ट्री कार्यान्वित करें

एल्गोरिदम

ट्री के नोड्स को इनपुट के रूप में लें। डेटा d, बाएं पॉइंटर l और दाएं पॉइंटर r के साथ nod संरचना बनाएं। create() फ़ंक्शन बनाएं: नोड्स की संख्या c = 0 प्रारंभ करें। जब तक c < 6 तब तक लूप चलाएं: रूट दर्ज करें, नोड का मान दर्ज करें, यदि यह रूट से बड़ा है तो दाएं डालें अन्यथा बाएं। inorder(), preorder(), postorder() फ़ंक्शन बनाएं क्रमशः लेफ्ट-रूट-राइट, रूट-लेफ्ट-राइट, लेफ्ट-राइट-रूट ट्रैवर्सल के लिए। main() से फ़ंक्शन कॉल करें और परिणाम प्रिंट करें।

उदाहरण कोड

#include <iostream>
using namespace std;

struct nod {
    nod *l, *r;
    int d;
} *r = NULL, *p = NULL, *np = NULL, *q;

void create() {
    int v, c = 0;
    while (c < 6) {
        if (r == NULL) {
            r = new nod;
            cout << "रूट नोड का मान दर्ज करें\n";
            cin >> r->d;
            r->r = NULL;
            r->l = NULL;
        } else {
            p = r;
            cout << "नोड का मान दर्ज करें\n";
            cin >> v;
            while (true) {
                if (v < p->d) {
                    if (p->l == NULL) {
                        p->l = new nod;
                        p = p->l;
                        p->d = v;
                        p->l = NULL;
                        p->r = NULL;
                        cout << "बाएं में मान डाला गया\n";
                        break;
                    } else if (p->l != NULL) {
                        p = p->l;
                    }
                } else if (v > p->d) {
                    if (p->r == NULL) {
                        p->r = new nod;
                        p = p->r;
                        p->d = v;
                        p->l = NULL;
                        p->r = NULL;
                        cout << "दाएं में मान डाला गया\n";
                        break;
                    } else if (p->r != NULL) {
                        p = p->r;
                    }
                }
            }
        }
        c++;
    }
}

void inorder(nod *p) {
    if (p != NULL) {
        inorder(p->l);
        cout << p->d << endl;
        inorder(p->r);
    }
}

void preorder(nod *p) {
    if (p != NULL) {
        cout << p->d << endl;
        preorder(p->l);
        preorder(p->r);
    }
}

void postorder(nod *p) {
    if (p != NULL) {
        postorder(p->l);
        postorder(p->r);
        cout << p->d << endl;
    }
}

int main() {
    create();
    cout << "इनऑर्डर में ट्रैवर्सल\n";
    inorder(r);
    cout << "प्रीऑर्डर में ट्रैवर्सल\n";
    preorder(r);
    cout << "पोस्टऑर्डर में ट्रैवर्सल\n";
    postorder(r);
    return 0;
}

आउटपुट

रूट नोड का मान दर्ज करें
7
नोड का मान दर्ज करें
6
बाएं में मान डाला गया
नोड का मान दर्ज करें
4
बाएं में मान डाला गया
नोड का मान दर्ज करें
3
बाएं में मान डाला गया
नोड का मान दर्ज करें
2
बाएं में मान डाला गया
नोड का मान दर्ज करें
1
बाएं में मान डाला गया
इनऑर्डर में ट्रैवर्सल
1
2
3
4
6
7
प्रीऑर्डर में ट्रैवर्सल
7
6
4
3
2
1
पोस्टऑर्डर में ट्रैवर्सल
1
2
3
4
6
7