C# में List में निर्दिष्ट तत्व मौजूद है या नहीं जांचना (Contains)

List<T>.Contains() मेथड जांचता है कि निर्दिष्ट तत्व लिस्ट में मौजूद है या नहीं। यह डिफ़ॉल्ट समानता तुलनाकर्ता (EqualityComparer<T>.Default) का उपयोग करता है। समय जटिलता O(n) है क्योंकि यह रैखिक खोज करता है।

उदाहरण 1: स्ट्रिंग लिस्ट में तत्व जांचना

using System;
using System.Collections.Generic;

public class Demo {
    public static void Main(string[] args) {
        List<string> list1 = new List<string>();
        list1.Add("One");
        list1.Add("Two");
        list1.Add("Three");
        list1.Add("Four");
        list1.Add("Five");

        Console.WriteLine("List1 में तत्व...");
        foreach (string item in list1) {
            Console.WriteLine(item);
        }

        List<string> list2 = new List<string>();
        list2.Add("India");
        list2.Add("US");
        list2.Add("UK");
        list2.Add("Canada");
        list2.Add("Poland");
        list2.Add("Netherlands");

        Console.WriteLine("\nList2 में तत्व (एन्यूमरेटर से)...");
        List<string>.Enumerator enumerator = list2.GetEnumerator();
        while (enumerator.MoveNext()) {
            Console.WriteLine(enumerator.Current);
        }

        // रेफरेंस समानता जांच (False - अलग ऑब्जेक्ट्स)
        Console.WriteLine("\nक्या List2, List1 के बराबर है? = " + list2.Equals(list1));
        
        // Contains - मान समानता जांच
        Console.WriteLine("क्या List2 में 'Canada' है? = " + list2.Contains("Canada"));
        Console.WriteLine("क्या List2 में 'Germany' है? = " + list2.Contains("Germany"));
    }
}

आउटपुट

List1 में तत्व...
One
Two
Three
Four
Five

List2 में तत्व (एन्यूमरेटर से)...
India
US
UK
Canada
Poland
Netherlands

क्या List2, List1 के बराबर है? = False
क्या List2 में 'Canada' है? = True
क्या List2 में 'Germany' है? = False

उदाहरण 2: इंटीजर लिस्ट में तत्व जांचना

using System;
using System.Collections.Generic;

public class Demo {
    public static void Main(string[] args) {
        List<int> list = new List<int>();
        list.Add(100);
        list.Add(200);
        list.Add(300);
        list.Add(400);
        list.Add(500);
        list.Add(600);
        list.Add(700);
        list.Add(800);
        list.Add(900);
        list.Add(1000);

        Console.WriteLine("List में तत्व...");
        foreach (int item in list) {
            Console.WriteLine(item);
        }

        Console.WriteLine("\nक्या List में 150 है? = " + list.Contains(150));
        Console.WriteLine("क्या List में 500 है? = " + list.Contains(500));
    }
}

आउटपुट

List में तत्व...
100
200
300
400
500
600
700
800
900
1000

क्या List में 150 है? = False
क्या List में 500 है? = True

महत्वपूर्ण बिंदु

• समय जटिलता: O(n) - रैखिक खोज करता है।
• प्रकार-सुरक्षित: जेनेरिक List<T> के साथ कंपाइल-टाइम प्रकार जांच।
• कस्टम तुलना: कस्टम तुलना के लिए List.Find() या LINQ .Any() उपयोग करें।
• बार-बार खोज: यदि बार-बार खोज की आवश्यकता है, तो HashSet<T> (O(1)) या SortedSet<T> (O(log n)) उपयोग करने पर विचार करें।
• नल मान: रेफरेंस टाइप्स के लिए नल मान जांचा जा सकता है।

LINQ विकल्प

using System.Linq;

// कस्टम शर्त के साथ जांच
bool hasEven = list.Any(x => x % 2 == 0);

// केस-इनसेंसिटिव स्ट्रिंग खोज
bool hasName = names.Any(n => n.Equals("john", StringComparison.OrdinalIgnoreCase));