में प्राथमिकता बदलें SortedList
का उपयोग करके PriorityQueue<T>
लिखने के लिए मैंने this question (जेसन द्वारा उत्तर) में दिए गए निर्देशों का पालन किया। मैं समझता हूं कि इस वर्ग के भीतर count
फ़ील्ड का उपयोग अद्वितीय प्राथमिकताओं को सुनिश्चित करने और समान प्राथमिकता के बीच एनक्यू ऑर्डर को संरक्षित करने के लिए किया जाता है।प्राथमिकता कतार
हालांकि, count
अपने अधिकतम मूल्य तक पहुंचता है और मैं इसके लिए 1 योग करता हूं, बाद वाला 0 से फिर से शुरू होगा, इसलिए बाद की वस्तुओं की प्राथमिकता पिछले आइटम की प्राथमिकता से अधिक होगी। इस दृष्टिकोण मैं एक तरह से करने के लिए "सुरक्षित रूप से" काउंटर count
रीसेट के लिए की जरूरत सकता है का उपयोग करना ... वास्तव में, लगता है निम्नलिखित कतार राज्य के लिए (प्रारूप प्राथमिकता में | गिनती | मद):
0 | 123 | एक
0 | 345 | बी
1 | 234 | सी
2 | 200 | डी
अब मान लीजिए कि काउंटर सीमा तक पहुंच गई है, इसलिए मुझे इसे 0 पर रीसेट करना होगा: परिणामस्वरूप, अगले डालने वाले आइटम में काउंटर 0 होगा: उदाहरण के लिए, यदि मैं 1 के बराबर प्राथमिकता वाले तत्व को सम्मिलित करता हूं, तो यह 1 से पहले गलत तरीके से डाला जाएगा 234 | डी
0 | 123 | एक
0 | 345 | बी
1 | 000 | नया तत्व
1 | 234 | सी
2 | 200 | डी
प्राथमिकता की समस्या एक ढेर को लागू करने से हल किया जा सकता: मैं एक Heap
श्रेणी का निर्माण, तो मैं आदेश TPriority
द्वारा तत्वों को सॉर्ट करने में Heap<KeyValuePair<TPriority, TElement>
और एक कस्टम PriorityComparer
इस्तेमाल किया। एक int
और Telement एक string
के रूप में के रूप में TPriority को देखते हुए, PriorityComparer
इस प्रकार है:
public class MyComparer : IComparer<KeyValuePair<int, string>>
{
public int Compare(KeyValuePair<int, string> x, KeyValuePair<int, string> y)
{
return x.Key.CompareTo(y.Key);
}
}
...
int capacity = 10;
Heap<KeyValuePair<int, string>> queue;
queue = new Heap<KeyValuePair<int, string>>(capacity, new PriorityComparer());
...
अद्यतन इस तरह से (PriorityComparer
का उपयोग) में, मैं एक प्राथमिकता कतार लागू करने के लिए सफल हुए हैं। अब मैं रनटाइम पर अपने व्यवहार को संशोधित करने के लिए समर्थन जोड़ना चाहता हूं, यानी फीफो से प्राथमिकता सॉर्टिंग और इसके विपरीत स्विच करें। प्राथमिकता कतार के अपने कार्यान्वयन एक IComparer
क्षेत्र है के बाद से, मुझे लगता है कि इस क्षेत्र को संपादित करने के लिए, की तरह इस प्रकार एक Comparer
संपत्ति जोड़ने के लिए पर्याप्त है:
public IComparer
{
set
{
this._comparer = value;
}
}
इस बीच मैंने सोचा कि मैं एक अलग दृष्टिकोण काफ़ी होगा में: प्राथमिकताओं को प्रबंधित करने के लिए बाइनरी ढेर का उपयोग करने के बजाय, मैं अलग-अलग कतारों को लपेट सकता हूं (प्रत्येक पंक्ति में दी गई प्राथमिकता को संदर्भित किया जाता है)।
public class PriorityQueue<T, int>
{
private Queue<T> _defaultQueue;
private bool _priority;
private SortedList<int, Queue<T>> _priorityQueues;
public PriorityQueue(int capacity)
{
this._defaultQueue = new Queue<T>(capacity);
this._priority = false;
this._priorityQueues = new SortedList<int, Queue<T>>(0);
}
public void PriorityEnable()
{
this._priority = true;
}
public void PriorityDisable()
{
this._priority = false;
}
public void Enqueue(T item)
{
if (this._priority)
{
// enqueue to one of the queues
// with associated priority
// ...
}
else this._defaultQueue.Enqueue(item);
}
public T Dequeue()
{
if (this._priority)
{
// dequeue from one of the queues
// with associated priority and
// return
// ...
}
return this._defaultQueue.Dequeue();
}
}
- कैसे फीफो मोडको प्राथमिकता मोड से संक्रमण का प्रबंधन करने के लिए जब वहाँ अभी भी कर रहे हैं डिफ़ॉल्ट कतार में तत्वों? मैं उन्हें प्राथमिकता कतार में आइटम प्राथमिकता के आधार पर कॉपी कर सकता हूं ... अन्य बेहतर समाधान?
- प्राथमिकता मोड से फीफो मोड से संक्रमण का प्रबंधन कैसे करें? इस मामले में, मेरे पास कई प्राथमिकताएं होंगी, जिनमें तत्व हो सकते हैं, लेकिन अब उन्हें प्राथमिकता के अनुसार प्रबंधित नहीं करना है और आगमन के मूल आदेश को भी नहीं जानते ...
- मैं अलग-अलग की क्षमता का प्रबंधन कैसे कर सकता हूं कतारों?
- उपर्युक्त दो समाधानों के प्रदर्शन के बारे में क्या? कौन सा स्मृति का उपयोग करता है?
क्या मेरी प्रतिक्रिया आपकी समस्या के लिए कोई मदद है? – JeremyK