अब तीन विकल्प - पहले दो अधिक सामान्य हैं, जिसमें वे MillionIntegerList पर भरोसा नहीं करते हैं (जिसे मूल रूप से निर्दिष्ट नहीं किया गया था)। तीसरा मामला उस मामले में बेहतर है जहां बड़ी सूची पहले ही क्रमबद्ध है।
विकल्प 1
हाँ, वहाँ निश्चित रूप से इसे करने का एक बेहतर तरीका है, LINQ का उपयोग कर रहा है:
var common = MillionIntegerList.Intersect(TwoThousandIntegerList).ToList();
कि आंतरिक रूप से एक HashSet<int>TwoThousandIntegerList के माध्यम से बनाया का उपयोग करेगा, तो ऊपर के प्रत्येक तत्व देखो MillionIntegerList इसके भीतर - जो हर बार TwoThousandIntegerList के माध्यम से जाने से कहीं अधिक कुशल होगा।
आप केवल गैर काली सूची में डाल लोगों को चाहते हैं, आप की जरूरत है:
var valid = MillionIntegerList.Except(TwoThousandIntegerList).ToList();
ध्यान दें कि यदि आप केवल एक बार परिणामों पर पुनरावृति करने की जरूरत है, तो आप ToList कॉल निकाल देना चाहिए - मैं इसे करने के लिए शामिल किया है परिणामों को पूरा करें ताकि उन्हें कई बार सस्ता जांच की जा सके। यदि आप अभी पुनरावृत्त कर रहे हैं, तो Intersect या Except का वापसी मूल्य केवल स्ट्रीम परिणाम देगा, जिससे स्मृति उपयोग के मामले में यह बहुत सस्ता हो जाएगा।
विकल्प 2
आप वस्तुओं को LINQ के कार्यान्वयन के विवरण पर भरोसा करने के लिए नहीं करना चाहते हैं लेकिन आप अभी भी एक हैश आधारित दृष्टिकोण चाहते हैं:
var hashSet = new HashSet<int>(TwoThousandIntegerList);
hashSet.IntersectWith(MillionIntegerList);
// Now use hashSet
विकल्प 3
इस तथ्य का उपयोग करने का दृष्टिकोण कि बड़ी सूची सॉर्ट की गई है, निश्चित रूप से उपयोगी होगी।
मान लिया जाये कि आप नहीं पहले के साथ-साथ काली सूची में डाल सूची छँटाई बात नहीं, आप एक स्ट्रीमिंग (और सामान्य प्रयोजन) कार्यान्वयन इस तरह (untested) लिख सकता है:
// Note: to use this, you'd need to make sure that *both* sequences are sorted.
// You could either sort TwoThousandIntegerList in place, or use LINQ's OrderBy
// method.
public IEnumerable<T> SortedIntersect<T>(this IEnumerable<T> first,
IEnumerable<T> second) where T : IComparable<T>
{
using (var firstIterator = first.GetEnumerator())
{
if (!firstIterator.MoveNext())
{
yield break;
}
using (var secondIterator = second.GetEnumerator())
{
if (!secondIterator.MoveNext())
{
yield break;
}
T firstValue = firstIterator.Current;
T secondValue = secondIterator.Current;
while (true)
{
int comparison = firstValue.CompareTo(secondValue);
if (comparison == 0) // firstValue == secondValue
{
yield return firstValue;
}
else if (comparison < 0) // firstValue < secondValue
{
if (!firstIterator.MoveNext())
{
yield break;
}
firstValue = firstIterator.Current;
}
else // firstValue > secondValue
{
if (!secondIterator.MoveNext())
{
yield break;
}
secondValue = secondIterator.Current;
}
}
}
}
}
(आप एक IComparer<T> अगर आप समय लग सकता है टी पर तुलनीय होने के बजाय चाहता था।)
या तो सूची क्रमबद्ध है? –
असल में मिलियन पूर्णांक सूची को हल किया गया है, ब्लैकलिस्टेड – theIrishUser
नहीं है लेकिन ब्लैकलिस्ट को सॉर्ट करने की लागत कुछ भी नहीं है जो आप करना चाहते हैं। – Thomash