Computer >> कंप्यूटर ट्यूटोरियल >  >> प्रोग्रामिंग >> C++

C++ में बाइनरी ट्री को सर्कुलर डॉली लिंक्ड लिस्ट में बदलें


इस ट्यूटोरियल में, हम एक प्रोग्राम पर चर्चा करेंगे जो बाइनरी ट्री को सर्कुलर डॉली लिंक्ड लिस्ट में परिवर्तित करता है।

इसके लिए हमें एक बाइनरी ट्री प्रदान की जाएगी। हमारा कार्य लेफ्ट और राइट नोड्स को क्रमशः लेफ्ट और राइट एलिमेंट्स में बदलना होगा। और बाइनरी ट्री के इनऑर्डर को सर्कुलर लिंक्ड लिस्ट का क्रम अनुक्रम बनाना होगा।

उदाहरण

#include <iostream>
using namespace std;

// बाइनरी ट्री की नोड संरचना
struct Node {
    struct Node *left, *right;
    int data;
};

// राइट लिस्ट को लेफ्ट लिस्ट के अंत में जोड़ना
Node* concatenate(Node* leftList, Node* rightList) {
    // यदि एक लिस्ट खाली है तो दूसरी लिस्ट वापस करें
    if (leftList == NULL)
        return rightList;
    if (rightList == NULL)
        return leftList;

    Node* leftLast = leftList->left;
    Node* rightLast = rightList->left;

    // लेफ्ट लिस्ट को राइट लिस्ट से जोड़ना
    leftLast->right = rightList;
    rightList->left = leftLast;
    leftList->left = rightLast;
    rightLast->right = leftList;

    return leftList;
}

// सर्कुलर लिंक्ड लिस्ट में बदलना और हेड वापस करना
Node* bTreeToCList(Node* root) {
    if (root == NULL)
        return NULL;

    Node* left = bTreeToCList(root->left);
    Node* right = bTreeToCList(root->right);

    root->left = root->right = root;

    return concatenate(concatenate(left, root), right);
}

// सर्कुलर लिंक्ड लिस्ट प्रदर्शित करना
void print_Clist(Node* head) {
    cout << "Circular Linked List is:\n";
    Node* itr = head;
    do {
        cout << itr->data << " ";
        itr = itr->right;
    } while (head != itr);
    cout << "\n";
}

// नया नोड बनाना और पता वापस करना
Node* newNode(int data) {
    Node* temp = new Node();
    temp->data = data;
    temp->left = temp->right = NULL;
    return temp;
}

int main() {
    Node* root = newNode(10);
    root->left = newNode(12);
    root->right = newNode(15);
    root->left->left = newNode(25);
    root->left->right = newNode(30);
    root->right->left = newNode(36);

    Node* head = bTreeToCList(root);
    print_Clist(head);
    return 0;
}

आउटपुट

Circular Linked List is: 25 12 30 10 36 15
  1. C++ में बाइनरी ट्री कैमरे C++ में बाइनरी ट्री कैमरे

    मान लीजिए हमारे पास एक बाइनरी ट्री है; हम ट्री के नोड्स पर कैमरे लगाते हैं। अब प्रत्येक कैमरा एक नोड पर अपने माता-पिता, स्वयं और अपने बच्चों की निगरानी कर सकता है। हमें ट्री के सभी नोड्स की निगरानी के लिए आवश्यक कैमरों की न्यूनतम संख्या ज्ञात करनी है। यदि इनपुट है - तो आउटपुट 1 होगा, क्योंकि सभी क

  1. C++ में सॉर्टेड लिस्ट को बाइनरी सर्च ट्री में बदलना C++ में सॉर्टेड लिस्ट को बाइनरी सर्च ट्री में बदलना

    मान लीजिए हमारे पास एक सिंगली लिंक्ड लिस्ट है जहां एलिमेंट्स आरोही क्रम में सॉर्टेड हैं, हमें इसे हाइट-बैलेंस्ड BST में बदलना है। उदाहरण के लिए, अगर लिस्ट है [-10, -3, 0, 5, 9], तो संभावित ट्री होगा: इसे हल करने के लिए, हम इन स्टेप्स को फॉलो करेंगे: अगर लिस्ट खाली है, तो नल लौटाएं sortedListToBST

  1. C++ में बाइनरी ट्री में लिंक्ड लिस्ट C++ में बाइनरी ट्री में लिंक्ड लिस्ट

    मान लीजिए हमारे पास एक बाइनरी ट्री रूट और एक लिंक्ड लिस्ट है जिसका हेड पहला नोड है। हमें True लौटाना है अगर लिंक्ड लिस्ट में हेड से शुरू होने वाले सभी एलिमेंट्स बाइनरी ट्री में किसी डाउनवर्ड पथ से मेल खाते हैं, अन्यथा False। उदाहरण के लिए, अगर ट्री है: और लिंक्ड लिस्ट [1,4,2,6] है, तो आउटपुट true