C# अकादमी · पाठ

व्यवहार में List

जोड़ें, हटाएँ और खोजें।

पाठ 1, कुल 4 में से13 चरण

व्यवहार में List, CoddyKit पर C# अकादमी का एक निःशुल्क पाठ है। यह 4 में से 1वाँ पाठ है। आप नीचे पूरा पाठ निःशुल्क पढ़ सकते हैं—फिर अंतर्निहित कोड संपादक और 24/7 एआई ट्यूटर के साथ ब्राउज़र में इसका व्यावहारिक अभ्यास कर सकते हैं। यह C# अकादमी सीखने के मार्ग का हिस्सा है और आपकी प्रगति वेब तथा CoddyKit ऐप पर सिंक होती रहती है। C# अकादमी पाठ्यक्रम में कुल 4 पाठ शामिल हैं।

सूची<T> क्यों

List<T> C# में रोज़मर्रा में उपयोग की जाने वाली गतिशील सारणी है। यह System.Collections.Generic में मौजूद है और तत्व जोड़ते ही अपने-आप बढ़ती जाती है।

साधारण सारणी के विपरीत, आपको शुरुआत में इसका निश्चित आकार तय नहीं करना पड़ता। यह प्रकार-सुरक्षित है: List<int> में केवल int मान रखे जा सकते हैं और यह बात संकलन-समय पर पकड़ ली जाती है।

using System.Collections.Generic;

List<int> scores = new List<int>();
scores.Add(90);
scores.Add(85);

बनाना और प्रारंभ करना

आप संग्रह प्रारंभकर्ता का उपयोग करके सूची को तुरंत भर सकते हैं। यह संक्षिप्त और पढ़ने में आसान होता है।

कंपाइलर पर्दे के पीछे हर प्रविष्टि को Add विधि के आह्वान में बदल देता है, इसलिए परिणाम एक-एक करके तत्व जोड़ने जैसा ही होता है।

using System;
using System.Collections.Generic;

class Program {
    static void Main() {
        var fruits = new List<string> { "apple", "pear", "plum" };
        Console.WriteLine(fruits.Count);
    }
}

अनुक्रमण और गिनती

तत्वों तक शून्य-आधारित अनुक्रमणिका से पहुँचें, ठीक सारणी की तरह। list[0] पहला तत्व है।

सूची में कितने तत्व हैं, यह जानने के लिए Count का उपयोग करें, Length का नहीं। अनुक्रमणिका से पढ़ना या लिखना O(1) स्थिर समय में होता है।

using System;
using System.Collections.Generic;

class Program {
    static void Main() {
        var nums = new List<int> { 10, 20, 30 };
        Console.WriteLine(nums[1]);
        Console.WriteLine(nums.Count);
    }
}

Add और Insert करना

Add परिशोधित O(1) समय में तत्व को अंत में जोड़ता है। AddRange एक साथ कई तत्व जोड़ता है।

Insert(index, item) किसी स्थान पर तत्व रखता है और उसके बाद के सभी तत्वों को खिसकाता है। इसी कारण शुरुआत में Insert करना O(n) होता है, इसलिए संभव हो तो अंत में तत्व जोड़ना बेहतर है।

var list = new List<string> { "b", "c" };
list.Insert(0, "a");
list.AddRange(new[] { "d", "e" });
// list is now a, b, c, d, e

तत्व हटाना

Remove(item) मेल खाने वाला पहला मान हटाता है और मिलने पर true लौटाता है। RemoveAt(index) स्थान के आधार पर तत्व हटाता है।

दोनों बाद के तत्वों को बाईं ओर खिसकाते हैं, इसलिए बीच से हटाना O(n) होता है। RemoveAll एक शर्त लेता है और एक ही क्रमिक जाँच में सभी मेल खाने वाले तत्व हटा देता है।

using System;
using System.Collections.Generic;

class Program {
    static void Main() {
        var nums = new List<int> { 1, 2, 3, 4, 5 };
        nums.RemoveAll(n => n % 2 == 0);
        Console.WriteLine(string.Join(",", nums));
    }
}

सूची में खोजना

Contains बताता है कि कोई मान मौजूद है या नहीं; IndexOf उसका स्थान या -1 देता है। दोनों रैखिक रूप से जाँच करते हैं, यानी O(n)।

यदि आप किसी बड़ी सूची में मान के आधार पर बार-बार खोज करते हैं, तो यह रैखिक लागत बढ़ती जाती है। ऐसी स्थिति में HashSet या Dictionary अधिक उपयुक्त हो सकता है।

var names = new List<string> { "Ann", "Bob", "Cy" };
bool hasBob = names.Contains("Bob");   // true
int pos = names.IndexOf("Cy");          // 2

तत्वों पर चलना

हर तत्व को पढ़ने के लिए foreach चक्र सबसे स्पष्ट तरीका है। जब आपको अनुक्रमणिका की आवश्यकता हो, तब आप पारंपरिक for चक्र का भी उपयोग कर सकते हैं।

उसी सूची पर चल रहे foreach के अंदर तत्व न जोड़ें और न हटाएँ; इससे InvalidOperationException उत्पन्न होता है।

using System;
using System.Collections.Generic;

class Program {
    static void Main() {
        var colors = new List<string> { "red", "green", "blue" };
        foreach (var c in colors)
            Console.WriteLine(c);
    }
}

क्रमबद्ध करना

Sort() डिफ़ॉल्ट तुलना-विधि का उपयोग करके सूची को उसी स्थान पर क्रमबद्ध करता है। मनचाहे क्रम के लिए तुलना प्रतिनिधि दें।

क्रमबद्ध करने की लागत O(n log n) होती है। original को बदले बिना क्रमबद्ध copy पाने के लिए LINQ के OrderBy का उपयोग करें, जो नया अनुक्रम लौटाता है।

using System;
using System.Collections.Generic;

class Program {
    static void Main() {
        var nums = new List<int> { 4, 1, 3, 2 };
        nums.Sort();
        Console.WriteLine(string.Join(",", nums));
    }
}

क्षमता बनाम गिनती

Count मौजूदा तत्वों की संख्या है; Capacity वह संख्या है जितने तत्व आंतरिक सारणी का फिर से आवंटन किए बिना रखे जा सकते हैं।

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

var list = new List<int>(1000); // reserve capacity
for (int i = 0; i < 1000; i++)
    list.Add(i);
// no intermediate reallocations

विधि के तर्क के रूप में सूची

List<T> एक संदर्भ प्रकार है। इसे किसी विधि में देने पर संदर्भ भेजा जाता है, इसलिए विधि के अंदर किए गए बदलाव कॉल करने वाले कोड की सूची को प्रभावित करते हैं।

यदि कोई विधि केवल पढ़ती है, तो यह स्पष्ट करने के लिए IEnumerable<T> या IReadOnlyList<T> स्वीकार करें कि आप इसमें बदलाव नहीं करेंगे।

using System;
using System.Collections.Generic;

class Program {
    static void AddOne(List<int> xs) => xs.Add(1);
    static void Main() {
        var nums = new List<int>();
        AddOne(nums);
        Console.WriteLine(nums.Count); // 1
    }
}

रूपांतरण और प्रति बनाना

ToArray() निश्चित आकार वाली सारणी बनाता है; new List<T>(other) किसी दूसरे अनुक्रम की उथली प्रति तैयार करता है।

उथली copy सूची की संरचना की प्रति बनाती है, लेकिन उसी तत्व-संदर्भों को साझा करती है। इसलिए शामिल वस्तु में किया गया बदलाव दोनों सूचियों में दिखाई देता है।

var original = new List<int> { 1, 2, 3 };
int[] arr = original.ToArray();
var copy = new List<int>(original);

त्वरित जाँच

वह क्रिया चुनिए जिसकी लागत सबसे अधिक अलग दिखाई देती है।

इंटरैक्टिव पाठ में इसका उत्तर दें

पुनरावृत्ति

List<T> बढ़ने वाली, प्रकार-सुरक्षित सारणी है। अनुक्रमणिका से पहुँच और Count O(1) में होते हैं; अंत में Add करना परिशोधित O(1) समय लेता है।

बीच में तत्व डालना, हटाना और मान के आधार पर खोजना O(n) होता है, क्योंकि इसमें तत्वों को खिसकाना या क्रम से जाँचना पड़ता है। आकार ज्ञात होने पर पुनः-आवंटन से बचने के लिए क्षमता पहले से निर्धारित करें।

शुरुआत निःशुल्क

एआई शिक्षक के साथ C# सीखें — निःशुल्क

अपने ब्राउज़र में वास्तविक कोड लिखें और चलाएँ, चौबीसों घंटे एआई शिक्षक से तुरंत सहायता पाएँ, और वेब या ऐप पर वहीं से शुरू करें जहाँ आपने छोड़ा था।

पाठ्यक्रम: 93
पाठ: 346

निःशुल्क सीखना शुरू करें पूरा पाठ्यक्रम देखें

अक्सर पूछे जाने वाले प्रश्न

क्या “व्यवहार में List” पाठ निःशुल्क है?

हाँ—“व्यवहार में List” का पूरा पाठ यहाँ वेब पर निःशुल्क पढ़ा जा सकता है। इंटरैक्टिव अभ्यास (अंतर्निहित कोड संपादक और 24/7 एआई ट्यूटर) करने और C# अकादमी पाठ्यक्रम का बाकी हिस्सा अनलॉक करने के लिए CoddyKit PRO लें। C# अकादमी पाठ्यक्रम में कुल 4 पाठ शामिल हैं।

“व्यवहार में List” में मैं क्या सीखूँगा?

जोड़ें, हटाएँ और खोजें। आप ब्राउज़र में सीधे चलाए जाने वाले व्यावहारिक कोड के साथ C# अकादमी का अभ्यास करते हैं, और पाठ पूरा करते समय 24/7 एआई ट्यूटर आपके प्रश्नों के उत्तर देता है।

क्या C# अकादमी शुरू करने के लिए मुझे किसी अनुभव की आवश्यकता है?

पहले के अनुभव की आवश्यकता नहीं है। CoddyKit पर C# अकादमी शुरुआती से लेकर उन्नत शिक्षार्थियों तक सभी के लिए व्यवस्थित किया गया है, इसलिए आप यहीं से या शुरुआत से सीखना शुरू कर सकते हैं और अपनी गति से आगे बढ़ सकते हैं। यह 4 में से 1वाँ पाठ है।

“व्यवहार में List” पाठ पूरा करने में कितना समय लगता है?

CoddyKit का अधिकांश पाठ लगभग 5–10 मिनट में पूरा हो जाता है। हर पाठ छोटा और संवादात्मक है, इसलिए आप लगातार प्रगति करते हैं और वेब या ऐप पर वहीं से सीखना जारी रख सकते हैं जहाँ आपने छोड़ा था।

क्या मैं इस C# अकादमी पाठ में कोड लिख और चला सकता हूँ?

हाँ। हर C# अकादमी पाठ में एक अंतर्निर्मित कोड संपादक शामिल है, जिससे आप सीधे अपने ब्राउज़र में वास्तविक कोड लिख और चला सकते हैं और तुरंत एआई प्रतिक्रिया पा सकते हैं—स्थानीय सेटअप की आवश्यकता नहीं है।

इस पाठ्यक्रम के सभी पाठ

← C# अकादमी पर वापस जाएँ