सभी अंतरण डेटा खोजें, न केवल अद्वितीय मान

Question

मैंने सोचा कि मुझे Intersect समझा गया है, लेकिन यह पता चला कि मैं गलत था।

List<int> list1 = new List<int>() { 1, 2, 3, 2, 3}; 
List<int> list2 = new List<int>() { 2, 3, 4, 3, 4}; 

list1.Intersect(list2) =>  2,3 

//But what I want is: 
// => 2,3,2,3,2,3,3 

मैं की तरह एक तरह से समझ सकते हैं:

var intersected = list1.Intersect(list2); 
var list3 = new List<int>(); 
list3.AddRange(list1.Where(I => intersected.Contains(I))); 
list3.AddRange(list2.Where(I => intersected.Contains(I))); 

वहाँ LINQ में एक आसान तरीका है इस लक्ष्य को हासिल करने के लिए है?

मुझे यह बताने की ज़रूरत है कि मुझे परवाह नहीं है कि परिणाम किस क्रम में दिए गए हैं।

2,2,2,3,3,3,3 पूरी तरह ठीक है।

समस्या यह है कि मैं इसे बहुत बड़े संग्रह पर उपयोग कर रहा हूं, इसलिए मुझे दक्षता की आवश्यकता है।

हम वस्तुओं के बारे में बात कर रहे हैं, इनट्स नहीं। स्याही सिर्फ आसान उदाहरण के लिए थे, लेकिन मुझे एहसास हुआ कि इससे कोई फर्क पड़ सकता है।

Answer 1

चलिए देखते हैं कि हम निश्चित रूप से आप जो चाहते हैं उसे चित्रित कर सकते हैं या नहीं। अगर मैं ग़लत हूं तो मेरी गलती सुझाएं। आप चाहते हैं: सूची 1 के सभी तत्व, क्रमशः, सूची 2 में भी दिखाई देते हैं, इसके बाद सूची 2 के सभी तत्वों के बाद, यह सूची 1 में भी दिखाई देता है। हाँ?

सीधा लगता है।

return list1.Where(x=>list2.Contains(x)) 
    .Concat(list2.Where(y=>list1.Contains(y))) 
    .ToList(); 

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

list1set = new HashSet(list1); 
list2set = new HashSet(list2); 

return list1.Where(x=>list2set.Contains(x)) 
    .Concat(list2.Where(y=>list1set.Contains(y))) 
    .ToList(); 

जो केवल कुछ हजार की तुलना करता है, लेकिन संभवत: अधिक मेमोरी का उपयोग करता।

Answer 2

मुझे विश्वास नहीं है कि अंतर्निहित एपीआई के साथ यह संभव है। लेकिन आप जो परिणाम ढूंढ रहे हैं उसे पाने के लिए आप निम्न का उपयोग कर सकते हैं।

IEnumerable<T> Intersect2<T>(this IEnumerable<T> left, IEnumerable<T> right) { 
    var map = left.ToDictionary(x => x, y => false); 
    foreach (var item in right) { 
    if (map.ContainsKey(item)) { 
     map[item] = true; 
    } 
    } 
    foreach (var cur in left.Concat(right)) { 
    if (map.ContainsKey(cur)) { 
     yield return cur; 
    } 
    } 
} 

Answer 3

var set = new HashSet(list1.Intersect(list2)); 
return list1.Concat(list2).Where(i=>set.Contains(i));