🤞🏻 📄 🐩 पेड़ का सामान्य दृष्टिकोण, कार्यान्वयन और न केवल ⌚️ 👵 🍩

कई ने शायद एक सामान्य पेड़ के निर्माण को खोजने की कोशिश की, लेकिन खोज इंजन में केवल द्विआधारी वाले पाए गए ... द्विआधारी खोज पेड़, द्विआधारी पेड़ का ट्रैवर्सल और कई अन्य एल्गोरिदम।
हां, वास्तव में, सामान्य पेड़ का उपयोग कहीं भी नहीं किया जाता है, बाईपास धीमा है, उपयोग के मामले छोटे हैं।

इसलिए, मैंने यह सवाल पूछा और अब मैं बताऊंगा कि पेड़ कैसे बनाया जा रहा है। तो, आदर्श रूप से, सामान्य रूप के पेड़ की संरचना को तीन चर संग्रह करना चाहिए:

बड़े बेटे की ओर इशारा
भाई को इशारा
डेटा जिसे आप स्टोर करने जा रहे हैं

struct Tnode { int key; struct Tnode *son; struct Tnode *brother; }; typedef struct Tnode Node;

एक पॉइंटर को शीर्ष पर घोषित करें:

 Node *tree = NULL;

हमें पहले से सहमत होना चाहिए कि कैसे प्रवेश करना है, यह एक द्विआधारी वृक्ष नहीं है, और प्रत्येक शीर्ष पर कोई भी पुत्र हो सकता है।

+ 2 (या + ssbb 2) - पेड़ में सम्मिलन (एक सामान्य पेड़ के लिए, रास्ता लाइन द्वारा निर्दिष्ट किया जाता है, जहां आर जड़ है, सबसे बड़े बेटे के लिए संक्रमण है, बी भाई के लिए संक्रमण है);

मैं एक उदाहरण दूंगा:

 +r 1 + 2 + 3 + 3 +s 5 +sb 6 +sb 7

नतीजतन, यह पेड़ जारी किया जाएगा:

 1 2 5 3 6 7 3

सबसे पहले, एक फ़ंक्शन बनाएं जो एक वर्टेक्स जोड़ता है, अर्थात्, वर्टेक्स के लिए मेमोरी आवंटित करता है और इस शीर्ष पर एक पॉइंटर पास करता है (शुरू में कुछ भी असंबंधित)।

 Node *create_tree(int v) { Node *Tree = (Node *) malloc(sizeof(Node)); Tree->key = v; //     ,  ,   value Tree->son = NULL; Tree->brother = NULL; return Tree; }

आपको एक फ़ंक्शन भी बनाना होगा जो पथ स्ट्रिंग (+ bs ...) को संसाधित करता है। हर बार जब हम रूट से ट्रैवर्सल शुरू करते हैं, अगर यह नहीं बनाया जाता है, तो हम NULL को प्रिंट करते हैं (हम कुछ नहीं कर सकते हैं)। अगर कोई चोटी नहीं है, तो हमें इसे बनाना होगा। ट्री ट्री फंक्शन में जाएं और पॉइंटर को रूट पर लाएं।

नोट: नोड ** वृक्ष संरचना को पार करता है, प्रतिलिपि नहीं। यह हमें नोड * ट्री घोषणा के विपरीत, जो कुछ भी नहीं किया जा सकता है उसे बदलने की क्षमता देता है।

सामान्य तौर पर, हमें एक पॉइंटर को शीर्ष पर ढूंढना चाहिए, जिसमें हमें एक बेटा जोड़ने की आवश्यकता है:

 Node* add_node(Node **tree, const char *a) { Node* t = *tree; int value; scanf("%d", &value); int i = 0; while (a[++i] != '\0') { if (a[i] == 'r') { *tree = create_tree(value); //   t = *tree; return *tree; } if (a[i] == 's') { if (t = to_son(t)) // ,      continue; return NULL; // NULL } if (a[i] == 'b') { if (t = to_brother(t)) //    t continue; return NULL; } } if (t->son != NULL) { t = last_son(t); //    ,    //      , //     t->brother = create_tree(value); return t->brother; } else {//  ,    t->son = create_tree(value); return t->son; } }

इस तरह हम एक पेड़ का निर्माण करते हैं।

PS मेरा पहला लेख है, इसलिए कृपया कड़ाई से न्याय न करें

पेड़ का सामान्य दृष्टिकोण, कार्यान्वयन और न केवल

More articles: