Rimuovi elementi di lista a determinati indici

Question

Ho una lista che contiene alcuni elementi di tipo stringa.

List<string> lstOriginal; 

Ho un'altra lista che contiene gli identi che dovrebbero essere rimossi dal primo elenco.

List<int> lstIndices; 

avevo cercato di fare il lavoro con RemoveAt() metodo,

foreach(int indice in lstIndices) 
{ 
    lstOriginal.RemoveAt(indice); 
} 

ma si blocca e mi ha detto che "indice è fuori portata."

Answer 1

È necessario ordinare gli indici che si desidera tornare dal più grande al più piccolo per evitare di rimuovere qualcosa nell'indice sbagliato.

foreach(int indice in lstIndices.OrderByDescending(v => v)) 
{ 
    lstOriginal.RemoveAt(indice); 
} 

Ecco perché: diciamo che hanno una lista di cinque elementi, e si desideri rimuovere gli elementi a indici 2 e 4. Se si rimuove l'elemento allo 2 per primo, l'elemento che era all'indice 4 si troverebbe nell'indice 3 e l'indice 4 non sarebbe più incluso nell'elenco (causando l'eccezione). Se vai indietro, tutti gli indici saranno lì fino al momento in cui sarai pronto a rimuovere l'oggetto corrispondente.

Answer 2

Il motivo per cui questo accade è che quando si rimuove un elemento dall'elenco, l'indice di ciascun elemento dopo diminuisce effettivamente di uno, quindi se li si rimuove in ordine crescente e alcuni elementi vicino alla fine dell'originale la lista doveva essere rimossa, quegli indici ora non sono validi perché la lista diventa più breve man mano che gli articoli precedenti vengono rimossi.

La soluzione più semplice consiste nell'ordinare l'elenco di indici in ordine decrescente (indice più alto prima) e quindi scorrere iterato su quello.

Answer 3

Come nota a margine, nelle istruzioni foreach, è meglio non modificare l'Ienumerable su cui foreach è in esecuzione. L'errore fuori intervallo è probabilmente il risultato di questa situazione.

Answer 4

for (int i = 0; i < indices.Count; i++) 
{ 
    items.RemoveAt(indices[i] - i); 
} 

Answer 5

 var array = lstOriginal.ConvertAll(item => new int?(item)).ToArray(); 
     lstIndices.ForEach(index => array[index] = null); 
     lstOriginal = array.Where(item => item.HasValue).Select(item => item.Value).ToList(); 

Answer 6

Come stai popolando la lista degli indici? C'è un metodo RemoveAll molto più efficiente che potresti essere in grado di utilizzare. Per esempio, invece di questo:

var indices = new List<int>(); 
int index = 0; 
foreach (var item in data) 
    if (SomeFunction(data)) 
     indices.Add(index++); 

//then some logic to remove the items 

Si potrebbe fare questo:

data.RemoveAll(item => SomeFunction(item)); 

Questo riduce al minimo la copia di elementi a nuove posizioni nella matrice; ogni elemento viene copiato solo una volta.

Si potrebbe anche usare una conversione metodo di gruppo nell'esempio di cui sopra, al posto di un lambda:

data.RemoveAll(SomeFunction); 

Answer 7

cancellazione My sul posto di determinati indici come metodo di estensione a portata di mano. Copia tutti gli elementi una sola volta, quindi è molto più performante se è necessario rimuovere una grande quantità di informazioni.

Getta anche ArgumentOutOfRangeException nel caso in cui l'indice da rimuovere sia fuori limite.

public static class ListExtensions 
{ 
    public static void RemoveAllIndices<T>(this List<T> list, IEnumerable<int> indices) 
    { 
     //do not remove Distinct() call here, it's important 
     var indicesOrdered = indices.Distinct().ToArray(); 
     if(indicesOrdered.Length == 0) 
      return; 

     Array.Sort(indicesOrdered); 

     if (indicesOrdered[0] < 0 || indicesOrdered[indicesOrdered.Length - 1] >= list.Count) 
      throw new ArgumentOutOfRangeException(); 

     int indexToRemove = 0; 
     int newIdx = 0; 

     for (int originalIdx = 0; originalIdx < list.Count; originalIdx++) 
     { 
      if(indexToRemove < indicesOrdered.Length && indicesOrdered[indexToRemove] == originalIdx) 
      { 
       indexToRemove++; 
      } 
      else 
      { 
       list[newIdx++] = list[originalIdx]; 
      } 
     } 

     list.RemoveRange(newIdx, list.Count - newIdx); 
    } 
}