Finden Sie gemeinsame Gegenstände in zwei Listen

Question

Mein Problem ist, dass ich zwei Listen vergleichen und Menge von Objekten, die gleichen Wert des Feldes teilen müssen. Suchen Sie nach gemeinsamen Objekten aus zwei Listen oder einigen Join-Operationen. Ich möchte Linq nicht verwenden, da ich später auf Indizes von Elementen zugreifen müsste, aber für jetzt sind die Klassen/Methoden vereinfacht. Klasse Pip:

public class Pip{ 
    public CONTROLLER.COLORS Color; 
} 

Vereinfachen Klasse-Sequenz, die im Grunde Liste des Kerns ist

public class Sequence{ 
    private List<Pip> pips = new List<Pip>(); 

    public Sequence(Pip[] pips) 
    { 
     for (int i = 0; i < pips.Length; i++) 
     { 
      addPip(pips[i]); 
     } 
    } 
    public List<Pip> getPips() 
    { 
     return pips; 
    } 
} 

So, jetzt habe ich diese Methode, die mir Menge an pips der gleichen Farbe für zwei Sequenzen zurückkommen wird, wobei jeder Pip ist von einer Farbe.

private int getMatchedColors(Sequence lockSeq, Sequence checkSeq) 
{ 
    List<Pip> lockPips = lockSeq.getPips(); 
    List<Pip> checkPips = checkSeq.getPips(); 
    List<Pip> excludedPips = new List<Pip>(lockPips.Count); 
    int matchedColors = 0; 

    for (int i = 0; i < lockPips.Count; i++) 
     for (int j = 0; j < checkPips.Count; j++) 
      if (checkPips[i].Color == lockPips[j].Color && !excludedPips.Contains(lockPips[j])) 
      { 
       matchedColors++; 
       excludedPips.Add(lockPips[j]); 
       break; 
      } 
    return matchedColors; 
} 

Die Logik beginnt mein Grund ist der nächste. Nehmen Sie jedes Element der lockPips Liste und vergleichen Sie die aktuelle Pip-Farbe mit der aktuellen Farbe checkPips 'List Pip. Wenn eine Übereinstimmung auftritt, prüfen wir, ob der übereinstimmende lockPips 'aktuelle Pip bereits überprüft wurde. Wenn nicht, dann erhöhen wir den Zähler und fügen lockPips 'aktuellen Pip zur Liste checkedPips hinzu und stellen so sicher, dass er bei der nächsten Überprüfung übersprungen wird.

Debugging zeigt, dass excludedPips Liste enthält bereits den Pip, der zum ersten Mal überprüft wurde und es verwendet seine Farbe bei jeder Überprüfung damit Algorithmus überspringen alle Anweisungen in "Wenn" -Anweisung.

Beispiele: lockPips: rot, grün, grün checkPips: rot, grün, grün erwartet matchedColors: 3 tatsächlicher matchedColors: 1 (rot)

lockPips: blau, blau, blau checkPips: blau, blau ROT erwartet matchedColors: 2 tatsächlichen matchedColors: 1 (BLAU)

So das Ergebnis bei einer tatsächlichen matchedColors> 0 1.

Answer 1

Sie müssen Ihre eigenen lo nicht schreiben gic für diesen Zweck, weil Sie Ihr gewünschtes Ergebnis erhalten können, indem Sie die Methode LINQ und Intersect verwenden. Wie folgt aus:

List<Pip> excludedPips = lockPips.Intersect(checkPips).ToList(); 

Und auch in Ihrer Klasse:

public class Pip 
{ 
    public string Color { get; set; } 

    public override bool Equals(object obj) 
    { 
     if (!(obj is Pip)) 
      return false; 
     Pip p = (Pip)obj; 
     return (p.Color == Color); 
    } 
    public override int GetHashCode() 
    { 
     return String.Format("{0}", Color).GetHashCode(); 
    } 
} 

Oder wenn Sie die gemeinsame entsprechenden Elemente von zwei List-Nutzung erhalten Zip:

List<Pip> excludedPips = lockPips.Zip(checkPips , (f,s) => f.Color == s.Color ? f : null) 
            .Where(c => c!= null).ToList(); 

Answer 2

Sie etwas tun könnte so

List<Pip> Matches = new List<Pip>(L1); 

// Get the matches 
Matches.AddRange(L2.Except(Matches)); 
Matches.RemoveAll(pip=> !L2.Contains(pip)); 

Dann, wenn Sie den ursprünglichen Index des gewünschten pip in Spielen so etwas wie diese

List<int> indexes = new List<int>(); 

if (L1.Contains(desiredPip)) indexes = Enumerable.Range(0, L1.Count).Where(i => L1[i].Color == desiredPip.Color).ToList(); 

if (L2.Contains(desiredPip)) indexes = Enumerable.Range(0, L2.Count).Where(i => L2[i].Color == desiredPip.Color).ToList(); 

finden wollen Ich weiß, Sie sagen, Sie nicht LINQ verwenden wollten, aber wenn Ihr einzigen Grund ist, dass Sie mögen, Zugriff auf die Indizes löst dieses Problem.