myCSharp.de - DIE C# und .NET Community
Willkommen auf myCSharp.de! Anmelden | kostenlos registrieren
 
 | Suche | FAQ

» Hauptmenü
myCSharp.de
» Startseite
» Forum
» FAQ
» Artikel
» C#-Snippets
» Jobbörse
» Suche
   » Plugin für Firefox
   » Plugin für IE
   » Gadget für Windows
» Regeln
» Wie poste ich richtig?
» Datenschutzerklärung
» wbb-FAQ

Mitglieder
» Liste / Suche
» Stadt / Anleitung dazu
» Wer ist wo online?

Angebote
» ASP.NET Webspace
» Bücher
» Zeitschriften
   » dot.net magazin
» Accessoires

Ressourcen
» .NET-Glossar
» guide to C#
» openbook: Visual C#
» openbook: OO
» .NET BlogBook
» MSDN Webcasts
» Search.Net

Team
» Kontakt
» Übersicht
» Wir über uns
» Bankverbindung
» Impressum

» Unsere MiniCity
MiniCity
» 10 Jahre myCSharp.de Diskussionsforum
Du befindest Dich hier: Community-Index » Diskussionsforum » Knowledge Base » FAQ » [FAQ] Listenelemente suchen und entfernen
Letzter Beitrag | Erster ungelesener Beitrag Druckvorschau | An Freund senden | Thema zu Favoriten hinzufügen

Antwort erstellen
Zum Ende der Seite springen  

[FAQ] Listenelemente suchen und entfernen

 
Autor
Beitrag « Vorheriges Thema | Nächstes Thema »
ErfinderDesRades
myCSharp.de-Poweruser/ Experte

images/avatars/avatar-3151.jpg


Dabei seit: 31.01.2008
Beiträge: 4.480


ErfinderDesRades ist offline

[FAQ] Listenelemente suchen und entfernen

Beitrag: beantworten | zitieren | editieren | melden/löschen       | Top

Gelegentlich muß man aus einer Auflistung bestimmte Elemente entfernen. Dabei läuft man leicht in einen typischen Anfänger-Fehler, nämlich in einem Vorwärts-Durchgang die Treffer entfernen zu wollen.
Das ist in etwa vergleichbar mit dem Absägen des Astes, auf dem man sitzt. Augenzwinkern

Als Beispiel nehme ich eine List<int>numbs mit Zufallszahlen, und alle Vielfachen von 3 sollen entfernt werden.

Wie es nicht geht

Die erste Variante des Fehlers würde foreach verwenden:

C#-Code:
foreach(int n in numbs) if(n % 3 == 0) numbs.Remove(n);

Das quittiert die Laufzeit mit einer InvalidOperationException: "Auflistungen können während der Enumeration nicht verändert werden". Grund ist, dass foreach über das IEnumerable-Interface den Enumerator der Auflistung abruft, ein Objekt, welches von einem Element zum nächsten vorrückt. Wenn nun während des Enumerierens Elemente zugefügt oder entfernt werden, ist das Verhalten des Enumerators nicht definiert, und daher wird sicherheitshalber die Exception geworfen.
Die Exception ist uns übrigens sehr nützlich, denn falls der Enumerator mit einer variablen Auflistung umgehen könnte, würde er dasselbe tückische Fehlverhalten produzieren, wie die folgende Variante des Fehlers, die Vorwärts-for-Schleife:

C#-Code:
for(int i = 0; i < numbs.Count; i++) if(numbs[i] % 3 == 0) numbs.RemoveAt(i);

Dieses würde zwar abgearbeitet werden, jedoch falsche Ergebnisse zeitigen - sehen wir die Datenmenge nach verschiedenen Durchläufen an:

Ausgangs-Datenmenge
i: 0 1 2 3 4 5 6 7
n: 8 6 3 5 8 1 2 9

Erster Treffer bei i == 1. Danach sehen die Daten so aus:

i: 0 1 2 3 4 5 6 7
n: 8 3 5 8 1 2 9

Anschließend wird i auf 2 gesetzt. Durch die Entfernung des vorigen Treffers sind aber die folgenden Elemente nach vorn gerückt, und nun liegt eine 3 auf Position 1, wird aber nicht mehr geprüft, denn Zähler i steht schon auf 2.
Das tückische daran ist, dass die übersprungene Prüfung nur dann falsche Daten erzeugt, wenn zwei Treffer aufeinander folgen.

Wie es geht

Aus obiger Betrachtung ergibt sich direkt die "naive" Lösung, nämlich die Liste eben rückwärts zu durchlaufen:

C#-Code:
for(int i = numbs.Count; i-- > 0; ) if(numbs[i] % 3 == 0) numbs.RemoveAt(i);

(Es ist also möglich, den Ast abzusägen, man darf nur nicht zwischen sich selbst und dem Stamm sägen Augenzwinkern )

Aufwandsklasse der naiven Lösung

In üblichen arraybasierten Auflistungen (zB List<T>) werden beim Löschen eines Elementes intern alle Folge-Elemente um einen Platz nach vorne kopiert. Das heißt, bei jeder Löschung wird im Durchschnitt intern die halbe Liste durchlaufen. Eine Verdopplung der Element-Anzahl würde sowohl eine doppelte Treffer-Zahl mitbringen, als auch bei jedem Treffer doppelt so viele zu verrückende Elemente. Daraus ergibt sich eine quadratische Proportionalität zw. Anzahl der Elemente und dem Aufwand der Operation, also eine Aufwandsklasse von O(n^2).
Codestellen mit quadratischem Aufwand sollte man möglichst vermeiden, daher stelle ich im folgenden 3 Verbesserungen vor, die die unerwünschten Elemente in nur einem Durchgang entfernen (linearer Aufwand: O(n)).
Die Verbesserungen sind aber nicht bei allen Auflistungen anwendbar (Beispiele folgen), sodaß manchmal zur naiven Lösung keine Alternative besteht.

Verbesserung#1: Liste umkopieren, dabei Treffer auslassen

C#-Code:
var list2 = new List<int>();
foreach(int n in numbs) if(n % 3 != 0) list2.Add(n);

Hierbei wird zeitweilig der doppelte Speicherplatz belegt, aber wenn das nur kurz ist, ist das nicht von Belang. Ernster ist die Gefahr, dass anderweitig noch eine Referenz auf die Ursprungs-Liste vorhanden sein mag, sodaß
  1. der Speicher der Ursprungs-Liste nicht freigegeben wird
  2. andernorts evtl. noch mit der veralteten Liste gearbeitet wird (Redundanz-Problem)
Verbesserung#2: Liste in sich selbst umkopieren

C#-Code:
for(int i = 0; i < numbs.Count; i++) {
   if(numbs[i] % 3 == 0) {
      /*Die Treffer werden nicht entfernt, sondern ab dem ersten Treffer werden die folgenden
       * Elemente nach vorn kopiert - Treffer werden dadurch überschrieben */

      int i2 = i;
      for(i++; i < numbs.Count; i++) {
         if(numbs[i] % 3 != 0) numbs[i2++] = numbs[i];
      }
      //erst ganz zuletzt werden die überzähligen Stellen vom Ende her entfernt
      numbs.RemoveRange(i2, i - i2);
   }
}

Verbesserung#3: die dafür vorgesehene Methode nutzen Augenzwinkern

Der gesamte bisherige Code ist nicht praxis-relevant, und muß gewissermaßen als PseudoCode angesehen werden, denn die Auflistung List<T> bringt bereits eine Methode .RemoveAll(Predicate<T> match) mit, die genau das ausführt, was als Verbesserung#2 ausprogrammiert ist. Man muß nur einen Delegaten angeben, der bestimmt, ob ein Element zu entfernen ist, und List<T>.RemoveAll() entfernt alle diese Elemente, in nur einem Durchgang:

C#-Code:
numbs.RemoveAll(delegate(int n) { return n % 3 == 0; });
//oder
numbs.RemoveAll(n => n % 3 == 0);

Spezielle Auflistungen

ControlCollection
Hier sind obige Verbesserungen nicht anwendbar. Da der Indexer readonly ist, kann dem i-ten Element kein anderes Control zugewiesen werden. Und natürlich kann man auch nicht eine ControlCollection durch eine andere austauschen, wie in Verbesserung#1 gezeigt. Wir müssen also auf die einfachste Lösung, das Rückwärts-Laufen, zurückgreifen.

C#-Code (Entfernen aller Labels aus einer Groupbox):
ControlCollection ctrls = grpMultiControls.Controls;
for(int i = ctrls.Count; i-- > 0; ) if(ctrls[i] is Label) ctrls.RemoveAt(i);

Verbesserungen an der Schleife wären hier ohnehin kaum sinnvoll, da erstens die gezeigten Verbesserungen erst bei tausenden von Elementen meßbare Wirkung entfalten, und zweitens das Entfernen eines einzigen Controls und Freigabe seiner Ressourcen ungleich langsamer ist als hunderte von Schleifendurchläufen.
Im Gegenteil - man kann sogar auf Kosten der Schleifen-Performance die Lesbarkeit etwas verbessern:

C#-Code:
foreach(int c in grpMultiControls.Controls.OfType<Label>().ToArray()) c.Dispose();

Dieser Code ähnelt sehr dem Anfänger-Fehler mit foreach, allerdings wird hier mittels .ToArray() flugs eine Kopie der Auflistung geschaffen und durchlaufen, während die Löschungen die Ursprungs-Liste treffen.

TreenodeCollection und ListviewItemCollection
Möglicherweise sind dieses die Auflistungen, aus denen am häufigsten unerwünschte Elemente gelöscht werden sollen. Wie die ControlCollection sind auch diese eng an eine andere Klasse gekoppelt, und weder als ganzes austauschbar, noch lassen sich Elemente umkopieren. Als Algorithmus kommt also ebenfalls nur die Rückwärts-Schleife in Frage.

Da die drei letztgenannten Auflistungen direkt auf dem Bildschirm angezeigt werden, ist hier bei Mehrfach-Operationen eine Optimierung der Anzeige dringend angeraten - nämlich das zeitweilige Aussetzen ihrer Aktualisierung.
Für die ControlCollection bedeutet das, eingangs ParentControl.SuspendLayout() aufzurufen, und nach Abschluß der Mehrfach-Operation ParentControl.ResumeLayout().

C#-Code:
grpMultiControls.SuspendLayout();
grpMultiControls.Controls.OfType<Label>().ToList().ForEach(c => c.Dispose());
grpMultiControls.ResumeLayout();

Treeview und Listview dagegen warten mit den Methoden .BeginUpdate() / .EndUpdate() auf, die entsprechend zu verwenden sind.


EDIT von herbivore: Wenn es um das Löschen doppelter Elemente geht, siehe  doppelte Werte einer Liste löschen.


Dateianhang:
zip DeleteElements02.zip (13,41 KB, 426 mal heruntergeladen)

Dieser Beitrag wurde 1 mal editiert, zum letzten Mal von ErfinderDesRades am 23.04.2010 22:30.

23.04.2010 22:28 E-Mail | Beiträge des Benutzers | zu Buddylist hinzufügen
Baumstruktur | Brettstruktur       | Top 
myCSharp.de | Forum Der Startbeitrag ist älter als 4 Jahre.
Der letzte Beitrag ist älter als 4 Jahre.
Antwort erstellen


© Copyright 2003-2014 myCSharp.de-Team. Alle Rechte vorbehalten. 23.04.2014 10:54