C# ऐरे स्थिर आकार के होते हैं, जिसका अर्थ है कि आप सीधे तौर पर तत्वों को हटा नहीं सकते और ऐरे का आकार नहीं बदल सकते। हालाँकि, कई तकनीकें तत्वों को हटाने का प्रभावी ढंग से अनुकरण करती हैं, अवांछित तत्वों के बिना एक नया ऐरे बनाती हैं या वैकल्पिक डेटा संरचनाओं का उपयोग करती हैं। यह लेख इन विधियों का पता लगाता है।
विषयवस्तु की तालिका
- कुशल निष्कासन के लिए LINQ का उपयोग करना
Listदृष्टिकोण- स्थान पर निष्कासन का अनुमान लगाना (उन्नत)
- निष्कर्ष
- अक्सर पूछे जाने वाले प्रश्न
कुशल निष्कासन के लिए LINQ का उपयोग करना
LINQ (भाषा एकीकृत क्वेरी) सबसे सरल समाधान प्रदान करता है। Where() क्लॉज एक शर्त के आधार पर तत्वों को फ़िल्टर करता है, केवल उन तत्वों वाले एक नए ऐरे का निर्माण करता है जो शर्त को पूरा करते हैं। यह प्रभावी रूप से उनको हटा देता है जो नहीं करते हैं।
int[] numbers = { 1, 2, 3, 4, 5, 6 };
int[] numbersWithoutThree = numbers.Where(n => n != 3).ToArray();
// numbersWithoutThree में अब {1, 2, 4, 5, 6} है
यह संक्षिप्त और पठनीय है। हालाँकि, याद रखें कि यह एक नया ऐरे बनाता है; मूल अपरिवर्तित रहता है।
List<T> दृष्टिकोण
गतिशील तत्व हटाने के लिए, List<T> बेहतर है। List<T> एक आकार बदलने योग्य संग्रह है, जो RemoveAt() या Remove() जैसी विधियों का उपयोग करके सीधे तत्व हटाने की अनुमति देता है।
List<int> numbersList = new List<int> { 1, 2, 3, 4, 5, 6 };
numbersList.RemoveAt(2); // इंडेक्स 2 (मान 3) पर तत्व को हटाता है
numbersList.Remove(5); // 5 की पहली घटना को हटाता है।
// एक ऐरे में वापस जाने के लिए:
int[] newArray = numbersList.ToArray();
यह दृष्टिकोण बार-बार जोड़ने और हटाने के लिए कुशल है, नए ऐरे बनाने के ओवरहेड से बचाता है।
स्थान पर निष्कासन का अनुमान लगाना (उन्नत)
जबकि C# ऐरे के साथ वास्तविक इन-प्लेस निष्कासन संभव नहीं है, हम तत्वों को स्थानांतरित करके इसका अनुकरण कर सकते हैं। यह LINQ या List<T> से कम कुशल है जब तक कि अत्यधिक बड़े ऐरे से निपटना न हो जहाँ नए ऐरे निर्माण को कम करना महत्वपूर्ण हो। हालाँकि, यह काफी अधिक जटिल है।
int[] numbers = { 1, 2, 3, 4, 5, 6 };
int indexToRemove = Array.IndexOf(numbers, 3);
if (indexToRemove != -1) {
Array.Copy(numbers, indexToRemove + 1, numbers, indexToRemove, numbers.Length - indexToRemove - 1);
Array.Resize(ref numbers, numbers.Length - 1);
}
यह विधि हटाए गए तत्व के बाद के तत्वों की प्रतिलिपि बनाती है, फिर ऐरे का आकार बदल देती है। ध्यान दें कि Array.Resize आंतरिक रूप से एक नया ऐरे बनाता है, कुछ संभावित मेमोरी लाभों को नकार देता है।
निष्कर्ष
अधिकांश परिदृश्यों के लिए, LINQ की Where() विधि का उपयोग करना या List<T> पर स्विच करना पठनीयता और दक्षता का सबसे अच्छा संतुलन प्रदान करता है। “इन-प्लेस” विधि पर केवल बहुत विशिष्ट प्रदर्शन-महत्वपूर्ण स्थितियों में विचार किया जाना चाहिए जिसमें अत्यधिक बड़े ऐरे हों जहाँ नए ऐरे आवंटन को कम करना सर्वोपरि हो। इसके उपयोग को सही ठहराने के लिए पूरी तरह से बेंचमार्किंग महत्वपूर्ण है।
अक्सर पूछे जाने वाले प्रश्न
प्रश्न: क्या मैं LINQ से कई तत्वों को हटा सकता हूँ?
उत्तर: हाँ, Where() लैम्ब्डा अभिव्यक्ति में अधिक जटिल स्थिति का उपयोग करें। उदाहरण के लिए, numbers.Where(n => n % 2 == 0).ToArray() विषम संख्याओं को हटा देता है।
प्रश्न: सूची में मान से तत्वों को हटाने के बारे में क्या?
उत्तर: Remove() विधि किसी विशिष्ट मान की पहली घटना को हटा देती है।
प्रश्न: कौन सी विधि सबसे तेज है?
उत्तर: आम तौर पर, छोटे से मध्यम आकार के ऐरे के लिए LINQ तेज होता है। अत्यधिक बड़े ऐरे के लिए, प्रदर्शन अंतर नगण्य हो सकता है, और “इन-प्लेस” विधि (हालांकि जटिल) कम आवंटन के कारण थोड़ा सा लाभ दिखा सकती है। विशिष्ट परिदृश्यों के लिए बेंचमार्किंग आवश्यक है।