किसी दिए गए आकार की सूची <T> को कैसे प्रारंभ करें (क्षमता के विपरीत)?

Question

.NET एक सामान्य सूची कंटेनर प्रदान करता है, जिसका प्रदर्शन लगभग समान है (Arrays बनाम Lists प्रश्न का प्रदर्शन देखें)। हालांकि वे आरंभीकरण में काफी भिन्न हैं।

डिफ़ॉल्ट मान के साथ प्रारंभ करना बहुत आसान है, और परिभाषा के अनुसार उनके पास पहले से ही निश्चित आकार है:

string[] Ar = new string[10];

जो किसी को यादृच्छिक आइटम को सुरक्षित रूप से निर्दिष्ट करने की अनुमति देता है, कहते हैं:

Ar[5]="hello";

सूची के साथ चीजें अधिक मुश्किल हैं। मैं एक ही आरंभीकरण करने के दो तरीके देख सकता हूं, जिनमें से कोई भी आपको सुरुचिपूर्ण नहीं कहेगा:

List<string> L = new List<string>(10);
for (int i=0;i<10;i++) L.Add(null);

या

string[] Ar = new string[10];
List<string> L = new List<string>(Ar);

क्लीनर तरीका क्या होगा?

संपादित करें: उत्तर अब तक क्षमता को संदर्भित करते हैं, जो किसी सूची को पूर्व-आबाद करने की तुलना में कुछ और है। उदाहरण के लिए, केवल 10 की क्षमता के साथ बनाई गई सूची में, कोई ऐसा नहीं कर सकता हैL[2]="somevalue"

EDIT 2: लोगों को आश्चर्य है कि मैं इस तरह से सूचियों का उपयोग क्यों करना चाहता हूं, क्योंकि यह वह तरीका नहीं है जिसका उपयोग करने का इरादा है। मैं दो कारण देख सकता हूं:

1. लगभग पूरी तरह से तर्क है कि सूची "अगली पीढ़ी" सरणियाँ हैं, लगभग कोई जुर्माना के साथ लचीलापन जोड़ते हुए। इसलिए एक डिफ़ॉल्ट रूप से उनका उपयोग करना चाहिए। मैं इंगित कर रहा हूं कि वे शुरू में आसान नहीं हो सकते।

2. वर्तमान में मैं जो लिख रहा हूं वह एक आधार वर्ग है जो एक बड़े ढांचे के हिस्से के रूप में डिफ़ॉल्ट कार्यक्षमता प्रदान करता है। डिफ़ॉल्ट कार्यक्षमता में, मैं सूची का आकार उन्नत में जाना जाता है और इसलिए मैं एक सरणी का उपयोग कर सकता था। हालांकि, मैं किसी भी बेस क्लास को गतिशील रूप से इसे विस्तारित करने का मौका देना चाहता हूं और इसलिए मैं एक सूची का विकल्प चुनता हूं।

Comments

"EDIT: उत्तर अब तक क्षमता का उल्लेख करते हैं, जो किसी सूची को पूर्व-आबाद करने की तुलना में कुछ और है। उदाहरण के लिए, सिर्फ 10 की क्षमता के साथ बनाई गई सूची पर, कोई L [2] =" somevalue "नहीं कर सकता है।" संशोधन, शायद आपको प्रश्न शीर्षक को

— पुन

लेकिन, खाली मान के साथ किसी सूची को पूर्व-आबाद करने का क्या उपयोग है, इसका कारण यह है कि विषय-वस्तु क्या करने की कोशिश कर रही है?

— फ्रेडरिक घीसेल्स

यदि स्थितीय मानचित्रण महत्वपूर्ण है, तो क्या यह शब्दकोश <int, string> का उपयोग करने के लिए अधिक समझ में नहीं आएगा?

— ग्रेग डी

Listके लिए एक प्रतिस्थापन नहीं है Array। वे अलग-अलग समस्याओं का समाधान करते हैं। यदि आप एक निश्चित आकार चाहते हैं, तो आप ए चाहते हैं Array। यदि आप एक का उपयोग करते हैं List, तो आप इसे गलत कर रहे हैं।

— ज़ेनेक्सर

मुझे हमेशा ऐसे उत्तर मिलते हैं जो "मैं देख सकता हूं कि मुझे कभी भी आवश्यकता नहीं होगी ..." जैसे तर्कों पर हथौड़ा चलाने की कोशिश करता है। इसका मतलब सिर्फ इतना है कि: आप इसे देख नहीं सकते। यह जरूरी कुछ और मतलब नहीं है। मैं इस बात का सम्मान करता हूं कि लोग किसी समस्या के बारे में बेहतर तरीके से सुझाव देना चाहते हैं, लेकिन यह अधिक विनम्रता से किया जाना चाहिए, जैसे "क्या आपको यकीन है कि आपको एक सूची की आवश्यकता है? शायद अगर आपने हमें अपनी समस्या के बारे में अधिक बताया ..."। इस तरह यह सुखद, आकर्षक और ओपी को अपने प्रश्न को सुधारने के लिए प्रोत्साहित करता है। विजेता बनो - विनम्र बनो।

— AnorZaken

Answer 1

मैं यह नहीं कह सकता कि मुझे इसकी बहुत बार आवश्यकता है - क्या आप इसके बारे में अधिक जानकारी दे सकते हैं कि आप ऐसा क्यों चाहते हैं? मैं शायद इसे सहायक कक्षा में एक स्थिर विधि के रूप में रखूँगा:

public static class Lists
{
    public static List<T> RepeatedDefault<T>(int count)
    {
        return Repeated(default(T), count);
    }

    public static List<T> Repeated<T>(T value, int count)
    {
        List<T> ret = new List<T>(count);
        ret.AddRange(Enumerable.Repeat(value, count));
        return ret;
    }
}

आप उपयोग कर सकते हैं Enumerable.Repeat(default(T), count).ToList()लेकिन बफर के आकार बदलने के कारण यह अक्षम होगा।

ध्यान दें कि यदि Tएक संदर्भ प्रकार है, तो यह पैरामीटर के countलिए पारित संदर्भ की प्रतियां संग्रहीत करेगा value- इसलिए वे सभी एक ही वस्तु को संदर्भित करेंगे। आपके उपयोग के मामले पर निर्भर करता है कि आप क्या चाहते हैं या नहीं हो सकता है।

संपादित करें: जैसा कि टिप्पणियों में उल्लेख किया गया है, आप Repeatedसूची को पॉप्युलेट करने के लिए एक लूप का उपयोग कर सकते हैं यदि आप चाहते थे। यह थोड़ा तेज भी होगा। व्यक्तिगत रूप से मुझे Repeatअधिक वर्णनात्मक का उपयोग करके कोड मिलता है , और संदेह है कि वास्तविक दुनिया में प्रदर्शन अंतर अप्रासंगिक होगा, लेकिन आपका लाभ भिन्न हो सकता है।

Comments

मुझे एहसास हुआ कि यह एक पुरानी पोस्ट है, लेकिन मैं उत्सुक हूं। लिंक के अंतिम भाग ( dotnetperls.com/initialize-array ) के अनुसार Enumerable.Repeat का किराया लूप की तुलना में बहुत बुरा है । इसके अलावा AddRange () में msdn के अनुसार O (n) जटिलता है। क्या यह एक साधारण लूप के बजाय दिए गए समाधान का उपयोग करने के लिए थोड़ा काउंटर उत्पादक नहीं है?

— जिमी

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

— जॉन स्कीट

@ जिमी: यह भी ध्यान दें कि वहाँ बेंचमार्क का उपयोग Enumerable.Repeat(...).ToArray()किया जा रहा है, जो नहीं है कि मैं इसका उपयोग कैसे कर रहा हूं।

— जॉन स्कीट

मैंने Enumerable.Repeat()निम्नलिखित तरीके से उपयोग किया है ( Pairसी ++ समकक्ष की तरह लागू किया गया है): Enumerable.Repeat( new Pair<int,int>(int.MaxValue,-1), costs.Count)साइड इफेक्ट को ध्यान में रखते हुए, जो Listकिसी एकल ऑब्जेक्ट को संदर्भित प्रतियों से भरा था। एक तत्व को बदलना जैसे myList[i].First = 1हर एक तत्व को पूरे में बदल दिया List। इस बग को खोजने में मुझे घंटों लग गए। क्या आप लोग इस मुद्दे का कोई हल जानते हैं (केवल एक सामान्य लूप और उपयोग को छोड़कर .Add(new Pair...)?

— 00zetti

@ Pac0, मैंने अभी नीचे एक उत्तर जोड़ा है। संपादन अस्वीकृत किया जा सकता है।

— जेरेमी रे ब्राउन

Answer 2

List<string> L = new List<string> ( new string[10] );

Comments

व्यक्तिगत रूप से मुझे लगता है कि यह सबसे साफ तरीका है - हालांकि यह प्रश्न शरीर में संभावित अनाड़ी के रूप में उल्लेख किया गया था - पता नहीं क्यों

— hello_earth

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

— चला गया

शानदार जवाब। @GoneCoding मैं बस सोच रहा था कि क्या आंतरिक रूप से नव आरंभ की गई सूची Lबस की स्मृति का पुन: उपयोग करेगी string[10]या नहीं (किसी सूची का बैकिंग स्टोर भी एक सरणी है) या यह अपनी खुद की एक नई स्मृति आवंटित करेगा और फिर सामग्री को कॉपी करेगा string[10]? string[10]यदि Lबाद में मार्ग का चयन किया जाता है तो स्वचालित रूप से कचरा एकत्र हो जाएगा ।

— RBT

@RBT इस दृष्टिकोण के लिए केवल नकारात्मक है: सरणी का पुन: उपयोग नहीं किया जाएगा, इसलिए आपके पास समय-समय पर सरणी की दो प्रतियां होंगी (सूची आंतरिक रूप से सरणियों का उपयोग करती है जैसा कि आप जानते हैं)। दुर्लभ मामलों में, यदि आपके पास भारी संख्या में तत्व, या मेमोरी की कमी है, तो यह एक समस्या हो सकती है । और हाँ अतिरिक्त सरणी सूची निर्माण के पूरा होते ही कचरा संग्रहण के लिए पात्र हो जाएगी (यह एक भयानक मेमोरी लीक हो गई होगी)। ध्यान दें कि पात्र का अर्थ "तुरंत एकत्र किया गया" नहीं है, बल्कि अगली बार कचरा संग्रह चलता है।

— ३० पर १ '

यह उत्तर 10 नए स्ट्रिंग्स आवंटित करता है - फिर आवश्यकता के अनुसार उन्हें कॉपी करके पुन: प्रसारित करता है। यदि आप बड़े सरणियों के साथ काम कर रहे हैं; तब भी इस पर विचार न करें क्योंकि इसे स्वीकृत उत्तर की तुलना में दो बार मेमोरी की आवश्यकता होती है।

— UKMonkey

Answer 3

एक तर्क के रूप में एक इंट ("क्षमता") लेने वाले निर्माता का उपयोग करें:

List<string> = new List<string>(10);

संपादित करें: मुझे यह जोड़ना चाहिए कि मैं फ्रेडरिक से सहमत हूं। आप सूची का उपयोग इस तरह से कर रहे हैं जो पहली जगह में इसका उपयोग करने के पीछे पूरे तर्क के खिलाफ जाता है।

EDIT2:

संपादित 2: मैं वर्तमान में जो लिख रहा हूं वह एक आधार वर्ग है जो एक बड़े ढांचे के हिस्से के रूप में डिफ़ॉल्ट कार्यक्षमता प्रदान करता है। डिफ़ॉल्ट कार्यक्षमता में, मैं सूची का आकार उन्नत में जाना जाता है और इसलिए मैं एक सरणी का उपयोग कर सकता था। हालांकि, मैं किसी भी बेस क्लास को गतिशील रूप से इसे विस्तारित करने का मौका देना चाहता हूं और इसलिए मैं एक सूची का विकल्प चुनता हूं।

किसी को सभी अशक्त मूल्यों के साथ सूची के आकार को जानने की आवश्यकता क्यों होगी? यदि सूची में कोई वास्तविक मूल्य नहीं हैं, तो मैं लंबाई की उम्मीद करूंगा 0. किसी भी तरह, तथ्य यह है कि यह स्पष्ट है कि यह वर्ग के इच्छित उपयोग के खिलाफ जा रहा है।

Comments

यह उत्तर सूची में 10 नल प्रविष्टियों को आवंटित नहीं करता है (जो आवश्यकता थी), यह बस 10 प्रविष्टियों के लिए स्थान आवंटित करता है इससे पहले कि सूची का आकार बदलने की आवश्यकता हो (क्षमता), इसलिए यह new List<string>()समस्या के रूप में दूर करने के लिए अलग से कुछ भी नहीं करता है । हालांकि इतने सारे अप-वोट प्राप्त करने पर किया गया :)

— कोडिंग किया गया

ओवरलोडेड कंस्ट्रक्टर "प्रारंभिक क्षमता" मान "आकार" या "लंबाई" नहीं है, और यह आइटम को इनिशियलाइज़ नहीं करता है

— मैट विल्को

"किसी को इसकी आवश्यकता क्यों होगी" इसका जवाब देने के लिए: मुझे गहरी क्लोनिंग ट्री डेटा संरचनाओं के लिए अभी इसकी आवश्यकता है। एक नोड अपने बच्चों को आबाद कर सकता है या नहीं कर सकता है, फिर भी मेरे आधार नोड वर्ग को अपने बच्चे के सभी नोड्स के साथ खुद को क्लोन करने में सक्षम होना चाहिए। ब्ला, ब्ला यह और भी जटिल है। लेकिन मुझे अपनी खाली सूची को list[index] = obj;और कुछ अन्य सूची क्षमताओं का उपयोग करने के लिए दोनों की आवश्यकता है।

— Bitterblue

@Bitterblue: इसके अलावा, किसी भी प्रकार की पूर्व-आवंटित मैपिंग जहां आपके सामने सभी मान नहीं हो सकते हैं। निश्चित रूप से उपयोग होते हैं; यह उत्तर मैंने अपने कम अनुभवी दिनों में लिखा था।

— एड एस।

Answer 4

पहले इच्छित आइटमों की संख्या के साथ एक सरणी बनाएं और फिर सरणी को एक सूची में परिवर्तित करें।

int[] fakeArray = new int[10];

List<int> list = fakeArray.ToList();

Answer 5

यदि आप एक निश्चित मूल्य के साथ इसे शुरू करना चाहते हैं तो आप एक सूची का उपयोग क्यों कर रहे हैं? मैं समझ सकता हूं कि प्रदर्शन के लिए-आप इसे एक प्रारंभिक क्षमता देना चाहते हैं, लेकिन एक नियमित सरणी पर सूची के फायदों में से एक नहीं है कि यह जरूरत पड़ने पर बढ़ सके?

जब आप ऐसा करते हैं:

List<int> = new List<int>(100);

आप एक सूची बनाते हैं जिसकी क्षमता 100 पूर्णांक है। इसका मतलब है कि आपकी सूची को 101 वें आइटम जोड़ने तक 'बढ़ने' की आवश्यकता नहीं होगी। सूची की अंतर्निहित सारणी को 100 की लंबाई के साथ आरंभीकृत किया जाएगा।

Comments

"आप एक सूची का उपयोग क्यों कर रहे हैं यदि आप इसे एक निश्चित मूल्य के साथ शुरू करना चाहते हैं" एक अच्छा बिंदु।

— एड एस।

उन्होंने एक सूची मांगी जिसमें प्रत्येक तत्व को आरंभीकृत किया गया था और सूची का आकार था, न कि केवल एक क्षमता। यह उत्तर गलत है क्योंकि यह अब खड़ा है।

— निक फोस्टर

प्रश्न के उत्तर की आवश्यकता है, न कि आलोचना की जा रही है। कभी-कभी इसे इस तरह से करने का एक कारण है, जैसा कि एक सरणी का उपयोग करने के विपरीत है। यदि दिलचस्पी है कि ऐसा क्यों हो सकता है, तो कोई इसके लिए स्टैक ओवरफ्लो प्रश्न पूछ सकता है।

— डिनो दीनी

Answer 6

उस सूची की सामग्री को आरम्भ करना जो वास्तव में सूची के लिए नहीं है। सूची वस्तुओं को रखने के लिए डिज़ाइन की गई हैं। यदि आप किसी विशेष ऑब्जेक्ट के लिए विशेष संख्याओं को मैप करना चाहते हैं, तो सूची के बजाय हैश टेबल या शब्दकोश जैसी कुंजी-मूल्य जोड़ी संरचना का उपयोग करने पर विचार करें।

Comments

यह प्रश्न का उत्तर नहीं देता है, लेकिन यह केवल एक कारण देता है कि इसे न पूछा जाए।

— डिनो दीनी

Answer 7

आप अपने डेटा के साथ एक स्थैतिक सहयोग की आवश्यकता पर जोर दे रहे हैं, इसलिए एक सहयोगी सरणी अधिक उपयुक्त नहीं होगी?

Dictionary<int, string> foo = new Dictionary<int, string>();
foo[2] = "string";

Comments

यह पूछे जाने वाले एक अलग प्रश्न का उत्तर दे रहा है।

— डिनो दीनी

Answer 8

यदि आप कुछ निश्चित मूल्य के एन तत्वों के साथ सूची को शुरू करना चाहते हैं:

public List<T> InitList<T>(int count, T initValue)
{
  return Enumerable.Repeat(initValue, count).ToList();
}

Comments

इस तकनीक द्वारा बफरिंग पर चिंता के लिए जॉन स्कीट का जवाब देखें।

— एमी बी

Answer 9

आप अपनी सूची को डिफ़ॉल्ट मान के साथ चतुराई से लिनेक का उपयोग कर सकते हैं। ( डेविड बी के जवाब के समान ।)

var defaultStrings = (new int[10]).Select(x => "my value").ToList();

एक कदम आगे बढ़ो और प्रत्येक स्ट्रिंग को अलग-अलग मान "स्ट्रिंग 1", "स्ट्रिंग 2", "स्ट्रिंग 3", आदि के साथ प्रारंभ करें।

int x = 1;
var numberedStrings = (new int[10]).Select(x => "string " + x++).ToList();

Answer 10

string [] temp = new string[] {"1","2","3"};
List<string> temp2 = temp.ToList();

Comments

कैसे के बारे में सूची <string> temp2 = नई सूची <string> (अस्थायी); जैसे ओपी ने पहले ही सुझाव दिया था।

— एड एस।

एड - यह वास्तव में सवाल का जवाब देता है - जो क्षमता के बारे में नहीं है।

— बोअज

लेकिन ओपी ने पहले ही कहा कि उन्हें यह समाधान पसंद नहीं है।

— एड एस।

Answer 11

स्वीकृत उत्तर (ग्रीन चेक मार्क वाला) का एक मुद्दा है।

समस्या:

var result = Lists.Repeated(new MyType(), sizeOfList);
// each item in the list references the same MyType() object
// if you edit item 1 in the list, you are also editing item 2 in the list

मैं ऑब्जेक्ट की एक कॉपी करने के लिए ऊपर की लाइन बदलने की सलाह देता हूं। इसके बारे में कई अलग-अलग लेख हैं:

• String.MemberwiseClone () विधि प्रतिबिंब के माध्यम से बुलाया काम नहीं करता है, क्यों?
• https://code.msdn.microsoft.com/windowsdesktop/CSDeepCloneObject-8a53311e

यदि आप NULL के बजाय डिफ़ॉल्ट निर्माता के साथ अपनी सूची में प्रत्येक आइटम को इनिशियलाइज़ करना चाहते हैं, तो निम्न विधि जोड़ें:

public static List<T> RepeatedDefaultInstance<T>(int count)
    {
        List<T> ret = new List<T>(count);
        for (var i = 0; i < count; i++)
        {
            ret.Add((T)Activator.CreateInstance(typeof(T)));
        }
        return ret;
    }

Comments

यह एक "मुद्दा" नहीं है - यह संदर्भों की नकल करने का सामान्य व्यवहार है। स्थिति को जाने बिना, आप यह नहीं जान सकते कि यह वस्तु की नकल करने के लिए उपयुक्त है या नहीं। सवाल यह नहीं है कि सूचियों को प्रतियों के साथ आबादी दी जानी चाहिए या नहीं - यह एक क्षमता के साथ सूची को शुरू करने के बारे में है। मैं व्यवहार में यह करने के मामले में मेरा उत्तर स्पष्ट करेंगे करता है, लेकिन मैं वास्तव में यह इस सवाल के संदर्भ में एक समस्या के रूप में गिना जाता है नहीं लगता।

— जॉन स्कीट

@JonSkeet, मैं स्टेटिक हेल्पर को जवाब दे रहा था, जो आदिम प्रकारों के लिए ठीक है, लेकिन संदर्भ प्रकारों के लिए नहीं। एक परिदृश्य जहां एक सूची को उसी संदर्भित आइटम के साथ आरंभीकृत किया जाता है वह सही नहीं लगता है। उस परिदृश्य में भी सूची क्यों होती है यदि इसमें मौजूद प्रत्येक वस्तु ढेर पर एक ही वस्तु की ओर इशारा करती है।

— जेरेमी रे ब्राउन

नमूना परिदृश्य: आप प्रत्येक तत्व के लिए "अज्ञात" की प्रविष्टि के साथ शुरू में, तार की एक सूची को पॉप्युलेट करना चाहते हैं, फिर आप विशिष्ट तत्वों के लिए सूची को संशोधित करते हैं। उस स्थिति में यह सभी "अज्ञात" मानों के लिए एक ही स्ट्रिंग के संदर्भ में पूरी तरह से उचित है। हर बार स्ट्रिंग को क्लोन करना व्यर्थ होगा। एक ही वस्तु के लिए कई संदर्भों के साथ एक स्ट्रिंग पॉपिंग सामान्य अर्थ में "सही" या "गलत" नहीं है। इसलिए जब तक पाठकों को पता है कि व्यवहार क्या है, यह तय करना उनके लिए है कि क्या यह उनके विशिष्ट उपयोग के मामले को पूरा करता है ।

— जॉन स्कीट

Answer 12

IList के बारे में एक नोटिस: MSDN IList टिप्पणियां : "IList कार्यान्वयन को तीन श्रेणियों में आते हैं:। केवल पढ़ने के लिए, निश्चित-आकार, और चर-आकार (...) इस इंटरफेस के जेनेरिक संस्करण के लिए, देखें। System.Collections.Generic.IList<T>।"

IList<T>से विरासत में नहीं मिलता IList(लेकिन List<T>दोनों को लागू करता है IList<T>और IList), लेकिन हमेशा चर-आकार होता है । .NET 4.5 के बाद से, हमारे पास भी IReadOnlyList<T>AFAIK है, लेकिन कोई निश्चित आकार की सामान्य सूची नहीं है जो कि आप देख रहे हैं।

Answer 13

यह एक नमूना है जिसका उपयोग मैंने अपनी इकाई परीक्षण के लिए किया था। मैंने क्लास ऑब्जेक्ट की एक सूची बनाई। तब मैंने 'X' ऑब्जेक्ट्स की संख्या को जोड़ने के लिए forloop का उपयोग किया था जो मुझे सेवा से उम्मीद है। इस तरह से आप किसी भी आकार के लिए सूची को जोड़ / आरंभ कर सकते हैं।

public void TestMethod1()
    {
        var expected = new List<DotaViewer.Interface.DotaHero>();
        for (int i = 0; i < 22; i++)//You add empty initialization here
        {
            var temp = new DotaViewer.Interface.DotaHero();
            expected.Add(temp);
        }
        var nw = new DotaHeroCsvService();
        var items = nw.GetHero();

        CollectionAssert.AreEqual(expected,items);


    }

आशा है कि मैं आप लोगों की मदद करूंगा।

Answer 14

थोड़ा देर से लेकिन पहला समाधान जो आपने प्रस्तावित किया वह मुझे बहुत साफ लगता है: आप दो बार मेमोरी आवंटित नहीं करते हैं। यहां तक ​​कि सूची की कमी करने वाले को इसे कॉपी करने के लिए सरणी के माध्यम से लूप की आवश्यकता होती है; यह पहले से ही पता नहीं है कि अंदर केवल अशक्त तत्व हैं।

1. - आवंटित एन - लूप एन लागत: 1 * आवंटित (एन) + एन * लूप_सिट्रेशन

2. - N आवंटित करें - N + लूप आवंटित करें () लागत: 2 * आवंटित करें (N) + N * loop_iteration

हालाँकि, लिस्ट का आबंटन तेज हो सकता है क्योंकि लिस्ट एक बिल्ट-इन क्लास है, लेकिन C # जिट-संकलित sooo है ...