Comment faire pour supprimer des éléments d'un tableau

Salut, je suis en train de travailler sur un code existant qui va quelque chose le long des lignes de

for(int i = results.Count-1; i >= 0; i--)
{
  if(someCondition)
  {
     results.Remove(results[i]);
  }
}

Pour moi, il semble comme une mauvaise pratique à enlever les éléments tout en toujours une itération dans la boucle parce que vous serez à la modification de l'index.

Est-ce correct?

Est-il une meilleure manière de faire ceci? Je voudrais utiliser LINQ mais je suis en 2.0 Cadre

ouais, en fait, vous ne pouvez pas le faire. Il doit lever une exception.
Il fonctionne jusqu'à ce que par la suppression d'un résultat que vous raccourcir la longueur d'un tableau et puis vous essayez d'accéder à quelque chose en dehors de la matrice.
[edite] en fait, rien que le code fait beaucoup de sens. ;-\
Le code du travail? Comment préférez-vous le faire? J'ai utilisé cette méthode, je suis donc intéressé de savoir si elle est "mauvaise pratique".
Si doit lancer une exception .

OriginalL'auteur Coder 2 | 2011-02-01

  1. 12

    Le déménagement est effectivement ok, puisque vous allez vers le bas à zéro, seuls les index que vous avez déjà passé vont être modifiés. Ce code aurait pause pour une autre raison: Il commence avec results.Count, mais devrait commencer à results.Count -1 puisque les indices de tableau commencent à 0.

    for(int i = results.Count-1; i >= 0; i--)
{
  if(someCondition)
  {
     results.RemoveAt(i);
  }
}

    Edit:

    Comme l'a souligné - vous réellement devez avoir à composer avec une Liste de certains de tri dans votre pseudo-code. Dans ce cas, ils sont essentiellement les mêmes (comme les Listes d'utiliser un Tableau à l'interne), mais si vous utilisez un tableau et que vous avez un Length de la propriété (au lieu d'un Count à la propriété) et vous ne pouvez pas ajouter ou supprimer des éléments.

    À l'aide d'une liste de la solution ci-dessus est certainement concis mais peut-être pas facile à comprendre pour quelqu'un qui a besoin de maintenir le code (à savoir en particulier l'itération dans la liste à l'envers) - une autre solution pourrait être d'identifier d'abord les éléments à supprimer, puis dans un second passage, la suppression de ces articles.

    Juste remplacer MyType avec le type réel vous avez à faire:

    List<MyType> removeItems = new List<MyType>();

foreach(MyType item in results)
{
   if(someCondition)
   {
        removeItems.Add(item);
   }
}

foreach (MyType item in removeItems)
    results.Remove(item);
    J'ai été surpris de voir plus de gens ne l'avais pas mentionné que c'est une itération à l'envers. +1
    Oui, il n'a besoin de ce que vous avez suggéré. J'ai manqué. Mis à jour.
    À ce point, pourquoi ne pas l'appeler RemoveAt? L'index est déjà prévu.
    bonne suggestion, j'ai fait une modification pour que
    BrokenGlass, votre approche alternative convertit origine O(n) code à O(n^2) Retirez avez à la recherche par le biais de toute la liste.

    OriginalL'auteur BrokenGlass

  2. 1

    Il ne semble pas que la suppression doit travailler à tous. Le IList mise en œuvre devrait échouer si nous avons affaire à un tableau de taille fixe, voir ici.

    Cela étant dit, si vous faites affaire avec un redimensionnable liste (par exemple, List<T>), pourquoi l'appeler Supprimer au lieu de RemoveAt? Puisque vous êtes déjà naviguer dans les indices dans le sens inverse, vous n'avez pas besoin de "re-trouver" le point.

    Ce n'est pas la façon dont vous utilisez un débordement de pile.

    OriginalL'auteur micahtan

  3. 1

    Puis-je suggérer un peu plus d'alternative fonctionnelle à votre code actuel:

    Au lieu de modifier le tableau existant à un seul élément à la fois, vous pourriez obtenir un nouveau un et ensuite de remplacer l'ensemble du tableau comme "atomique" de l'opération une fois que vous avez terminé:

    La voie de la facilité (pas de LINQ, mais très similaire):

    Predicate<T> filter = delegate(T item) { return !someCondition; };

results = Array.FindAll(results, filter);
//with LINQ, you'd have written: results = results.Where(filter);

    où T est le type des éléments de votre results tableau.

    Un peu plus explicite alternative:

    var newResults = new List<T>();
foreach (T item in results)
{
    if (!someCondition)
    {
        newResults.Add(item);
    }
}
results = newResults.ToArray();

    OriginalL'auteur stakx

  4. 0

    Habituellement, vous ne serait pas supprimer des éléments en tant que tel, vous devez créer un nouveau tableau à partir de l'ancien, sans les éléments non désirés.

    Si vous allez l'itinéraire de la suppression des éléments d'un tableau/liste de vos boucles, il faut compter vers le bas plutôt que vers le haut. (comme le vôtre)

    OriginalL'auteur Tim Jarvis

  5. 0

    un couple d'options:

    List<int> indexesToRemove = new List<int>();
for(int i = results.Count; i >= 0; i--)
{
  if(someCondition)
  {
     //results.Remove(results[i]);
       indexesToRemove.Add(i);
  }
}

foreach(int i in indexesToRemove) {
results.Remove(results[i]);
}

    ou sinon, vous pouvez faire une copie de la liste existante, et au lieu de supprimer de la liste originale.

    //temp is a copy of results
for(int i = temp.Count-1; i >= 0; i--)
{
  if(someCondition)
  {
     results.Remove(results[i]);
  }
}

    OriginalL'auteur Victor