स्केल में सूची के अंत में एक तत्व लागू करना

Question

यह एक बेवकूफी भरा सवाल लगता है, लेकिन मुझे इंटरनेट पर जो मिला वह सब कचरा था। मैं बस Tसूची में एक प्रकार का तत्व नहीं जोड़ सकता List[T]। मैंने कोशिश की, myList ::= myElementलेकिन ऐसा लगता है कि यह एक अजीब वस्तु बनाता है और myList.lastहमेशा उस पहले तत्व को वापस करता है जो सूची के अंदर डाला गया था।

Answer 1

List(1,2,3) :+ 4

Results in List[Int] = List(1, 2, 3, 4)

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

Comments

कोई ओ (2 * एन) नहीं है, एसिम्प्टोटिक जटिलताओं के लिए निरंतर कारकों की अनदेखी की जाती है। मुझे लगता Listहै ListBufferकि तत्व में बदल दिया गया है , तत्व को जोड़ दिया गया है, और ListBufferपरिवर्तित पीठ (बहुत पसंद है Stringऔर StringBuilderजावा में), लेकिन यह सिर्फ एक अनुमान है।

— लैंडेई

यह O (n) है क्योंकि आपको अंतिम तत्व पॉइंटर तक पहुंचने के लिए पूरी तरह से सूची को पीछे करना होगा और अंतिम तत्व पॉइंटर पॉइंट बनाने वाले तत्व को जोड़ने में सक्षम होना चाहिए।

— 1

@pisaruk अगर ऐसा होता, तो कोई भी सिर और पूंछ के लिए एक सूचक रख सकता था। हालांकि, स्केला में सूची अपरिवर्तनीय है, जिसका अर्थ है कि सूची के अंतिम तत्व को "संशोधित" करने के लिए पहले इसकी एक प्रतिलिपि बनाने की आवश्यकता है। इसकी प्रति जो O (n) है - सूची का नहीं है।

मेरा मानना ​​है कि यह O (n) है क्योंकि केवल एक नई सूची बनाता है

— राफेल रोसी

विपक्ष ऑपरेटर में जटिलता ओ (1) है, क्योंकि यह सूची के "इच्छित" पक्ष पर काम करता है।

— लांडेई

Answer 2

ऐसा इसलिए है क्योंकि आपको ऐसा नहीं करना चाहिए (कम से कम एक अपरिवर्तनीय सूची के साथ)। यदि आपको वास्तव में एक डेटा संरचना के अंत में एक तत्व को संलग्न करने की आवश्यकता है और इस डेटा संरचना को वास्तव में एक सूची बनाने की आवश्यकता है और इस सूची को वास्तव में अपरिवर्तनीय होना है तो यह करें:

(4 :: List(1,2,3).reverse).reverse

या वो:

List(1,2,3) ::: List(4)

Comments

आपका बहुत बहुत धन्यवाद! ठीक यही तो मैं खोज रहा था। मुझे लगता है कि आपके जवाब से मुझे ऐसा नहीं करना चाहिए, हालांकि ... मैं अपनी संरचना को संशोधित करूंगा और देखूंगा कि मैं क्या कर सकता हूं। एक बार फिर धन्यवाद।

— मासियर

यदि आप अपरिवर्तनीयता और कुशल परिशिष्ट चाहते हैं तो @Masiar एक वेक्टर का उपयोग करें। Scala-lang.org/docu/files/collections-api/collections.html

— Arjan Blokzijl

यदि आप कई तत्वों को जोड़ना चाहते हैं, तो "सूची का निर्माण करें और फिर इसे उल्टा कर दें" इसे एक उपयोगी पैटर्न है, लेकिन मुझे नहीं लगता कि इसे लागू करना एक अच्छा विचार है, जैसे आप किसी एक तत्व को जोड़ने के मामले में करते हैं। मौजूदा सूची। "डबल रिवर्स" ट्रिक सूची को दो बार पुनर्निर्मित करता है, जबकि :+, अक्षम, जैसा भी हो, केवल एक बार इसे फिर से बनाता है।

— निकोलस पैलेट

Answer 3

स्काला में सूचियों को संशोधित करने के लिए डिज़ाइन नहीं किया गया है। वास्तव में, आप तत्वों को स्केल में नहीं जोड़ सकते हैं List; यह जावा स्ट्रिंग की तरह एक अपरिवर्तनीय डेटा संरचना है । जब आप स्काला में "एक सूची में एक तत्व जोड़ते हैं" तब आप वास्तव में क्या करते हैं , एक मौजूदा सूची से एक नई सूची बनाना है । (स्रोत)

ऐसे उपयोग मामलों के लिए सूचियों का उपयोग करने के बजाय, मैं या तो ArrayBuffera या a का उपयोग करने का सुझाव देता हूं ListBuffer। उन डेटास्ट्रक्चर को नए तत्वों को जोड़ने के लिए डिज़ाइन किया गया है।

अंत में, आपके सभी ऑपरेशन किए जाने के बाद, बफर को फिर एक सूची में परिवर्तित किया जा सकता है। निम्नलिखित REPL उदाहरण देखें:

scala> import scala.collection.mutable.ListBuffer
import scala.collection.mutable.ListBuffer

scala> var fruits = new ListBuffer[String]()
fruits: scala.collection.mutable.ListBuffer[String] = ListBuffer()

scala> fruits += "Apple"
res0: scala.collection.mutable.ListBuffer[String] = ListBuffer(Apple)

scala> fruits += "Banana"
res1: scala.collection.mutable.ListBuffer[String] = ListBuffer(Apple, Banana)

scala> fruits += "Orange"
res2: scala.collection.mutable.ListBuffer[String] = ListBuffer(Apple, Banana, Orange)

scala> val fruitsList = fruits.toList
fruitsList: List[String] = List(Apple, Banana, Orange)

Answer 4

यह एक उत्तर के समान है लेकिन अलग-अलग तरीके से है:

scala> val x=List(1,2,3)
x: List[Int] = List(1, 2, 3)

scala> val y=x:::4::Nil
y: List[Int] = List(1, 2, 3, 4)

Answer 5

हम दो सूचियों या सूची को जोड़ सकते हैं या छोड़ सकते हैं और जोड़ सकते हैं
:

var l = List(1,2,3)    
l=l:+4 
Result : 1 2 3 4  
var ar = Array(4,5,6)    
for(x<-ar)    
{ l=l:+x}  
  l.foreach(println)

Result:1 2 3 4 5 6

prepending:

var l = List[Int]()  
   for(x<-ar)  
    { l=x::l } //prepending    
     l.foreach(println)   

Result:6 5 4 1 2 3

Comments

हां, हम कर सकते हैं, लेकिन अन्य उत्तरों में वर्णित सभी कारणों से यह एक बुरा विचार होगा।

— jwvh