मेरे पास एक असाइनमेंट है जहां मुझे एक बाइनरी सर्च ट्री का उपयोग करने की आवश्यकता है और इसे स्वयं ऑर्डर करने के लिए बदल देना चाहिए जैसे कि वे आइटम जो सबसे अधिक एक्सेस किए जाते हैं (एक उच्च प्राथमिकता) पेड़ के शीर्ष पर हैं, रूट सबसे अधिक एक्सेस किया जा रहा नोड है ।
प्रोफेसर ने मुझे काम करने के लिए BST और नोड स्ट्रक्चर दिया, लेकिन पेड़ को अपडेट करने के लिए एल्गोरिदम के आसपास मेरा सिर लाने की कोशिश की क्योंकि चीजें मुझे भ्रमित कर रही हैं।
मुझे पता है कि जैसा कि इंसर्ट हो रहा है, यह जांचता है कि क्या वर्तमान नोड का डेटा वर्तमान नोड से कम या अधिक है, तो पुनरावर्ती रूप से सही दिशा में जाता है जब तक कि यह एक शून्य पॉइंटर नहीं पाता है और वहां खुद को सम्मिलित करता है। और इसे डालने के बाद यह प्राथमिकता 1 से बढ़ा देता है।
template <class Type>
void BinarySearchTree<Type> :: insert( const Type & x, BinaryNode<Type> * & t )
{
if( t == NULL )
t = new BinaryNode<Type>( x, NULL, NULL );
else if( x < t->element )
insert( x, t->left );
else if( t->element < x )
insert( x, t->right );
else
t->priority++; // Duplicate; do nothing for right now
}
अब मुझे यह पता लगाने की आवश्यकता है कि जब नोड बराबर होता है, तो पेड़ को फिर से कैसे ऑर्डर किया जाए ताकि मौजूदा नोड (जो पहले से मौजूद नोड के बराबर है) मौजूदा नोड को पाता है, उस नोड की प्राथमिकता बढ़ जाती है, फिर इसे स्थानांतरित कर देता है यदि जड़ कम प्राथमिकता है।
मुझे लगता है कि मेरे पास यह विचार है कि एवीएल तर्क काम करेगा, और जब एक बदलाव होगा, तो यह एक एकल दाएं घूमेगा या एक रोटेशन होगा।
यहाँ मैं उलझन में हूँ, वास्तव में समस्या को हल करने के लिए एक एल्गोरिथ्म बनाने के साथ कहाँ शुरू करने के लिए पता नहीं है। चूंकि AVL एल्गोरिथ्म एक पेड़ के संतुलन को बनाए रखने के साथ काम करता है, फिर उसके अनुसार बाएं या दाएं घूमते हुए नोड्स, इस पेड़ को संतुलित होने के बारे में चिंता करने की आवश्यकता नहीं है, बस यह है कि उच्चतम प्राथमिकता वाले नोड्स में उच्च प्राथमिकता वाले बच्चे नहीं हैं। ।