स्कैला ने प्राथमिकता कतार का आदेश दिया है जिसमें हमेशा सिर के रूप में सबसे कम संख्या है, आरोही क्रम

Question

मैं एक कोड नमूना प्राप्त करना चाहता हूं जो प्राथमिकता कतार में वस्तुओं के आरोही क्रम को पूरा करता है।

मैं प्राथमिकता कतार के अंदर Tuple2(Int, String) स्टोर करना चाहता हूं ताकि इसे आरोही क्रम में टुपल के पहले तत्व द्वारा आदेश दिया जा सके। यदि मेरी प्राथमिकता कतार pq कहलाती है और मैं pq.head पर कॉल करता हूं, तो मैं pq.dequeue पर कॉल करने के साथ सबसे कम संख्या के साथ टुपल प्राप्त करना चाहता हूं।

scala> val pq = scala.collection.mutable.PriorityQueue[(Int, String)]() 
pq: scala.collection.mutable.PriorityQueue[(Int, String)] = PriorityQueue() 

scala> pq += Tuple2(8, "eight") 
res60: pq.type = PriorityQueue((8,eight)) 

scala> pq += Tuple2(4, "four") 
res61: pq.type = PriorityQueue((8,eight), (4,four)) 

scala> pq += Tuple2(7, "seven") 
res62: pq.type = PriorityQueue((8,eight), (4,four), (7,seven)) 

ऊपर दिए गए सम्मिलन के समय पहले तत्व द्वारा आरोही क्रम को कैसे लागू करें?

धन्यवाद

Answer 1

PriorityQueue.apply और PriorityQueue.empty दोनों एक अंतर्निहित Ordering उदाहरण है कि सामग्री सिर ऑर्डर करने के लिए है कि आदेश के अनुसार, "सबसे बड़ी" मूल्य होगा इस्तेमाल किया जाएगा ले। आपको टुपल्स के लिए डिफॉल्ट एक मिल रहा है, जो ट्यूपल के तत्वों पर एक लेक्सिकोग्राफिक ऑर्डरिंग है, जो आप नहीं चाहते हैं, क्योंकि इससे सिर के सबसे बड़े तत्व के साथ टुपल बन जाएगा।

इस मुद्दे को हल करने के कुछ तरीके हैं। सबसे आसान है कि आप अपनी कतार पर .reverse पर कॉल करें, जो आपको एक ही सामग्री के साथ एक नई कतार देगी लेकिन विपरीत क्रम, जिसका मतलब है कि सबसे कम मूल्य वाला टुपल सिर होगा।

import scala.collection.mutable.PriorityQueue 

val pq = PriorityQueue.empty[(Int, String)](
    implicitly[Ordering[(Int, String)]].reverse 
) 

या आप स्पष्ट रूप से दूसरा तत्व परामर्श किया जाना करने के लिए नहीं करना चाहते हैं:

val pq = PriorityQueue.empty[(Int, String)](
    Ordering.by((_: (Int, String))._1).reverse 
) 

यह संभवतः एक छोटे से है

आप अपना स्वयं का आदेश देने जब कतार बनाने प्रदान कर सकते हैं कतार को उलटने से अधिक कुशल, लेकिन संभवतः चिंता करने के लिए पर्याप्त नहीं है, इसलिए आपको केवल उस दृष्टिकोण को चुनना चाहिए जो आपको सबसे सुंदर लगता है।

Answer 2

scaladoc से

:

केवल dequeue और dequeueAll तरीकों प्राथमिकता क्रम में तरीकों वापस आ जाएगी (जबकि ढेर से तत्वों को हटाने)। drop और iterator समेत मानक संग्रह विधियां जो भी ऑर्डर सबसे सुविधाजनक लगती हैं, ढेर को हटा दें या पार करेंगी।

कि चेतावनी भी .head को लागू करने के लिए लगता है, लेकिन .dequeue क्रम में तत्वों देता है।

डिफ़ॉल्ट अनुक्रम उतरते है (सर्वोच्च प्राथमिकता पहले बाहर आता है के बाद से), लेकिन जब निर्माण आप स्पष्ट रूप से उलट आदेश पारित कर सकते हैं:

val normalOrder = implicitly[Ordering[(Int, String)]] 
val reversedOrder = Ordering.reverse(normalOrder) 
val pq = scala.collection.mutable.PriorityQueue[(Int, String)](reversedOrder) 

Answer 3

आप सभी की जरूरत निहित आदेश विपरीत हो रहा है, तो आप बस सकता है कतार को तुरंत उलट दें:

val pq = PriorityQueue.empty[(Int, String)].reverse