Les retirer de la liste, C#

Je suis en train de supprimer un nœud, si x actuellement correspond à un int dans ma liste liée.

J'ai essayé ceci, mais une fois qu'il supprime le nœud, il renvoie une erreur lors de l'examen de boucle foreach

public void DeleteNode(int x, LinkedList<name> myLinkedList) {
    foreach (name item in myLinkedList) {
         if (item.num.equals(x)) mylinkedList.Remove(x);
    }
}

L'espoir qui fait sens.

Ne pouvez pas utiliser un foreach, besoin de passer à un for.

OriginalL'auteur GodsCrimeScene | 2011-10-07

  1. 23

    Oui, vous ne pouvez pas effectuer une itération sur une collection et de le modifier en même temps. Cependant, LinkedList<T> vous permet de faire l'itération explicitement assez facilement:

    public void DeleteNode(int x, LinkedList<name> myLinkedList) {
    var node = myLinkedList.First;
    while (node != null) {
        var nextNode = node.Next;
        if (node.Value.num == x) {
            myLinkedList.Remove(node);
        }
        node = nextNode;
    }
}

    Notez que vous ne pouvez pas sortir avec juste de prendre node = node.Next; comme la dernière ligne de; le nœud est invalidé lorsqu'il est retiré.

    Cette approche permet à un seul de la traversée de la liste en O(n), et est probablement l'approche la plus efficace que vous trouverez. Il ne nécessite aucune copie, ou de travailler avec une collection (dire List<T>) avec de moins en moins efficace de suppression de la complexité.

    Cela a aussi l'avantage d'être en O(n) au lieu de O(n^2), considérant la complexité du temps de Remove(T) contre Remove(LinkedListNode<T>).
    Absolument. J'avais supposé que c'était implicite, mais je vais le modifier pour l'état 🙂
    Merci Jon, je suis toujours d'avoir une erreur sur la première partie, je ne peut pas convertir un .LinkedListNode<T>.LinkedList. Ma liste est une collection d'éléments, et pas seulement 1 int(bien que l'int est la partie que je suis en comparant)
    Qui "première partie"? Veuillez identifier la ligne de mon code que tu veux dire, et le exact d'erreur. Je vais modifier mon post pour y inclure la déclaration de la méthode.
    n'a pas la prétention d'être thread-safe pour commencer.

    OriginalL'auteur Jon Skeet

  2. 0

    Si vous appelez de supprimer au cours d'une foreach, elle invalide l'agent recenseur, ce n'est donc pas autorisé.

    Changer votre foreach à une simple for boucle.

    OriginalL'auteur Brandon Moretz

  3. 0

    Dans cette situation, j'ai l'habitude de créer un temporaire de la collecte et de l'ajouter à cela qu'il doit être supprimé. Ensuite je boucle qui liste la suppression de l'original.

    OriginalL'auteur Joshua Belden

  4. 0

    La façon dont j'écris, sans invalider l'itérateur, est:

    foreach(var item in list.Where(w=>w.num.Equals(x)).ToArray())
   list.Remove(item);
    Ça va être de O(n^2) si...
    C'est ce que Shlemiel le peintre le ferait.
    pour être juste, j'en doute vraiment des questions.. et bien sûr, je ne l'utilise que pour les tableaux, mais le code est assez solide pour tout itérateur de type.
    Pensez-vous qu'il est particulièrement rare de disposer d'une liste liée de, disons, 10 000 éléments? Ce n'est pas une collection énorme - mais la différence entre O(n) et O(n^2) est assez grande à ce point...
    cette chose (pour la plupart) s'aggrave par rapport au nombre d'articles que vous êtes supprimer, donc, si nous parlons d'une liste que vous pouvez supprimer des dizaines de milliers d'articles assez souvent que vous remarquerez la différence, alors oui, c'est un peu improbable.

    OriginalL'auteur Blindy

  5. 0

    - Je supprimer les Éléments de la liste de la manière suivante:

    for (int j = lst.Count - 1; j >= 0; j--)
   {
    var elem= lst[j];
    lst.Remove(elem);
    }

    Il ressemble de très près à la régulière "foreach var elem en lst", qui est la raison pour laquelle je l'aime.

    Je vais partir de la fin vers le début parce que sinon vous perdrez votre indexation, et aura besoin de suivre le nombre d'éléments supprimés.

    OriginalL'auteur ephraim