सेल्फ ऑर्डरिंग बाइनरी ट्री बनाना


20

मेरे पास एक असाइनमेंट है जहां मुझे एक बाइनरी सर्च ट्री का उपयोग करने की आवश्यकता है और इसे स्वयं ऑर्डर करने के लिए बदल देना चाहिए जैसे कि वे आइटम जो सबसे अधिक एक्सेस किए जाते हैं (एक उच्च प्राथमिकता) पेड़ के शीर्ष पर हैं, रूट सबसे अधिक एक्सेस किया जा रहा नोड है ।

प्रोफेसर ने मुझे काम करने के लिए 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 एल्गोरिथ्म एक पेड़ के संतुलन को बनाए रखने के साथ काम करता है, फिर उसके अनुसार बाएं या दाएं घूमते हुए नोड्स, इस पेड़ को संतुलित होने के बारे में चिंता करने की आवश्यकता नहीं है, बस यह है कि उच्चतम प्राथमिकता वाले नोड्स में उच्च प्राथमिकता वाले बच्चे नहीं हैं। ।

जवाबों:


12

सिर्फ दो संकेत:

  1. यदि आप वास्तव में प्राथमिकता कतार और द्विआधारी खोज पेड़ों के विचारों को संयोजित करना चाहते हैं, तो एक संरचना में ढेर और बीएसटी के संयोजन के बारे में सोचें।
  2. स्व-आयोजन सूचियों की अवधारणा है । यह विचार है कि भविष्य के एक्सेस को एक ही तत्व तक पहुँचाने के लिए हाल ही में एक्सेस किए गए तत्व (या) की ओर जाना है, इस प्रकार समय के साथ तत्व वितरण को "सीखना" है (विशेष कार्यान्वयन के आधार पर गुणवत्ता के साथ)। शायद आप इसे पेड़ों के लिए अनुकूलित कर सकते हैं?

Spoiler: नीचे दिए गए लिंक का पालन करें यदि आप स्वयं कुछ लेकर नहीं आ पाए हैं।

1. इसे ट्रैप कहा जाता है ।
2. सेले के पेड़ इस विचार को लागू करते हैं।


2

स्प्ले पेड़ों पर एक नज़र डालें, वे वास्तव में वही हैं जो आपको चाहिए। आपको स्प्ले फ़ंक्शन को संशोधित करना होगा, प्रत्येक एक्सेस किए गए नोड को पेड़ के सभी तरफ नहीं ले जाना चाहिए, लेकिन धीरे-धीरे ऊपर की तरफ


2
वह क्यों होता है यह परिवर्तन करने के लिए? या तो रणनीति व्यवहार्य है , और अन्य हैं। इसके अलावा, यह एक होमवर्क प्रश्न था / है ताकि संकेत (अनियोजित) समाधानों को प्राथमिकता दी जाए। अंत में, यह उत्तर बेमानी है; शायद आप अपने प्रस्तावित समाधान की ओर ओपी का नेतृत्व करने के लिए इसे बदल सकते हैं?
राफेल

ठीक है, आपके लिए कुछ संकेत तब: 1. स्प्ले फ़ंक्शन पर एक नज़र डालें और देखें कि यह क्या करता है, प्रश्न पढ़ें और यह पता करें कि यह क्या कहता है, इस आधार पर कि आप स्प्ले फ़ंक्शन को संशोधित करते हैं या नहीं। और नहीं, सभी रणनीतियां व्यवहार्य नहीं हैं क्योंकि उसके पास प्राथमिकता के आधार पर कुछ आवश्यकताओं को पूरा करने की आवश्यकता है, इसलिए हर समय मोर्चे पर शिफ्ट करना मान्य नहीं है। अधूरा समाधान? मेरा उत्तर और अधूरा समाधान कैसे है? 3. "निरर्थक के रूप में यह है" ... मैं नहीं देखता कि कैसे आपका जवाब, उफ़, माफ करना - संकेत अंतिम हैं और मेरा "अधूरा समाधान" तालिका में नोटिंग लाता है
Bober02
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.