Wie können Sie Strings in einer Liste aus einer anderen Liste entfernen?

Question

Ich habe 2 Liste welche Namen ListA und ListB sind.

möchte ich Strings in ListeB entfernen, die in listA sind, aber ich möchte dies auf diese Weise tun:

wenn listA enthält: "bar", "bar", "bar", "foo" und ListeB enthält: "bar"

es entfernt nur 1 bar und das Ergebnis wird sein: "bar", "bar", "foo"

der Code, den ich schrieb entfernt alle "bar":

List<string> result = listA.Except(listB).ToList(); 

Answer 1

Sie können versuchen, es eins nach dem anderen zu entfernen:

foreach (var word in listB) 
    listA.Remove(word); 

Die Remove-Methode ein Element nur zu einem Zeitpunkt entfernen wird und nicht Ausnahme werfen (aber Rückkehr false), wenn das Element nicht gefunden wird: https://msdn.microsoft.com/en-us/library/cd666k3e(v=vs.110).aspx

Answer 2

var listA = new List<string>() { "bar", "bar", "bar", "foo" }; 
var listB = new List<string>() { "bar" }; 

foreach (var word in listB){ 
    listA.Remove(word); 
} 

Answer 3

Dies ist eine schnellere Methode, aber es ist wahrscheinlich, die Reihenfolge der Elemente der ersten Liste zu ändern. Steps:

• Karte die Lista zu einem Dictionary<string, int> (lass es listAMap nennen), wo Schlüssel ist das Element der Liste und Wert ist die Gesamtzahl der für diesen Wert in listA aufgetreten ist;
• Iterieren durch listB und für jedes Element von listB, wenn dieses Element in der listAMap ist, reduzieren Sie die Anzahl;
• Holen Sie sich die Schlüssel von listMapA mit Keys property von C# -Dokumenten, und durchlaufen Sie alle Schlüssel. Für jeden Schlüssel, der einen positiven Wert hat, addiere diesen Schlüssel zu einer anderen Liste insgesamt seine Zählzeiten. Wenn also ein Eintrag "bar" -> 2 ist, dann fügen Sie zweimal "bar" in die neue Liste ein.

Gesamtlaufzeit des Algorithmus ist O (m + n), wobei m und n die Anzahl der Elemente in den beiden ursprünglichen Listen. Es ist eine bessere Laufzeit als andere Ansätze hier erwähnt, die O (m * n) Laufzeit haben. Offensichtlich benötigt dieser Algorithmus mehr Platz.

---

Supportive-Code für den Algorithmus oben:

//Step-1: Create the dictionary... 
var listAMap = new Dictionary<string, int>(); 
foreach (var listAElement in listA) 
{ 
    listAMap.ContainsKey(listAElement) ? listAMap[listAElement]++ : listAMap.Add(listAElement, 1); 
} 

// Step-2: Remove the listB elements from dictionary... 
foreach (var listBElement in listB) 
{ 
    if (listAMap.Contains(listBElement)) listAMap[listBElement]--; 
} 

//Step-3: Create the new list from pruned dictionary... 
var prunedListA = new List<string>(); 
foreach (var key in listAMap.Keys) 
{ 
    if (listAMap[key] <= 0) continue; 
    for (var count = 0; count < listAMap[key]; count++) 
    { 
     prunedListA.Add(key); 
    } 
} 

//prunedListA contains the desired elements now. 

Answer 4

Hier ist ein effizienter Weg, dies zu tun:

var countB = new Dictionary<string, int>(listB.Count); 
foreach (var x in listB) 
{ 
    int count; 
    countB.TryGetValue(x, out count); 
    countB[x] = count + 1; 
} 
listA.RemoveAll(x => 
{ 
    int count; 
    if (!countB.TryGetValue(x, out count)) return false; 
    if (count == 1) 
     countB.Remove(x); 
    else 
     countB[x] = count - 1; 
    return true; 
});