Implementierung einer verketteten Liste mit C#

Verkettete Listen sind eine fundamentale Datenstruktur in der Programmierung. Diese Datenstruktur besteht aus einer Sammlung von Knoten. Jedes Element oder Knoten referenziert das nächste Element. C# bietet dabei eine elegante Lösung zur Implementierung einer solchen Liste. Um jedoch ebenfalls rückwärts durch die Liste navigieren zu können, muss eine zusätzliche Referenz (zum vorherigen Element) eingerichtet werden.

Schritt 1: Konstruktion der Elemente

Zuerst ist es essentiell eine Klasse für die Listenelemente zu erstellen. Diese Klasse, nennen wir sie `Listenelement`, speichert sowie die Daten des Elements – wie etwa einen String – als auch zwei Referenzen: eine auf das nächste Element (`naechster`) und eine auf das vorherige Element (`vorgaenger`). Ein einfaches Code-Beispiel verdeutlicht dies:

```csharp
class Listenelement
{
public string daten;
public Listenelement naechster;
public Listenelement vorgaenger;

public Listenelement(string daten)
{
this.daten = daten;
naechster = null;
vorgaenger = null;
}
}
```

Schritt 2: Erstellung der verketteten Liste

Als nächstes definieren wir die `VerketteteListe`-Klasse. Diese Klasse enthält Methoden zur Verwaltung der Listenelemente. Besonders wichtig sind Funktionen zum Hinzufügen und Entfernen von Elementen. Aber auch die Durchlaufmethoden sind Bestandteil dieser Klasse. Ein Blick auf den dazugehörigen Code zeigt dies klar:

```csharp
class VerketteteListe
{
private Listenelement anfang;
private Listenelement ende;

public VerketteteListe()
{
anfang = null;
ende = null;
}

public void ElementAnhaengen(string daten)
{
Listenelement neuesElement = new Listenelement(daten);

if (ende == null)
{
anfang = neuesElement;
ende = neuesElement;
}
else
{
neuesElement.vorgaenger = ende;
ende.naechster = neuesElement;
ende = neuesElement;
}
}

public void ElementAmAnfangAnhaengen(string daten)
{
Listenelement neuesElement = new Listenelement(daten);

if (anfang == null)
{
anfang = neuesElement;
ende = neuesElement;
}
else
{
neuesElement.naechster = anfang;
anfang.vorgaenger = neuesElement;
anfang = neuesElement;
}
}

public void ElementEntfernen(string daten)
{
Listenelement aktuellesElement = anfang;

while (aktuellesElement != null)
{
if (aktuellesElement.daten == daten)
{
if (aktuellesElement.vorgaenger != null)
{
aktuellesElement.vorgaenger.naechster = aktuellesElement.naechster;
}
else
{
anfang = aktuellesElement.naechster;
}

if (aktuellesElement.naechster != null)
{
aktuellesElement.naechster.vorgaenger = aktuellesElement.vorgaenger;
}
else
{
ende = aktuellesElement.vorgaenger;
}

break;
}
aktuellesElement = aktuellesElement.naechster;
}
}

public void ListeAusgeben()
{
Listenelement aktuellesElement = anfang;

while (aktuellesElement != null)
{
Console.WriteLine(aktuellesElement.daten);
aktuellesElement = aktuellesElement.naechster;
}
}

public void ListeRueckwaertsAusgeben()
{
Listenelement aktuellesElement = ende;

while (aktuellesElement != null)
{
Console.WriteLine(aktuellesElement.daten);
aktuellesElement = aktuellesElement.vorgaenger;
}
}
}
```

Schritt 3: Anwendung der verketteten Liste

Die Nutzung der Liste ist denkbar einfach. Erstellt man ein Objekt der `VerketteteListe`, können Elemente hinzugefügt werden. Diese können dann sowohl vorwärts als auch rückwärts durchlaufen werden. Im Folgenden ein einfaches Beispiel:

```csharp
VerketteteListe liste = new VerketteteListe();
liste.ElementAmAnfangAnhaengen("Element 1");
liste.ElementAnhaengen("Element 2");
liste.ElementAnhaengen("Element 3");

liste.ListeAusgeben(); // Ausgabe: Element 1, Element 2, Element 3
liste.ListeRueckwaertsAusgeben(); // Ausgabe: Element 3, Element 2, Element 1

liste.ElementEntfernen("Element 2");
liste.ListeAusgeben(); // Ausgabe: Element 1, Element 3
```

Daraus folgt, dass diese Implementierung eine umfassende Lösung zur Verwaltung von verketteten Listen in C# bietet. Eine verkettete Liste kann dadurch effektiv vorwärts und rückwärts durchlaufen werden.

In der digitalen Welt von 2023 ist der effiziente Umgang mit Datenstrukturen wie verketteten Listen von großer Bedeutung. Die Möglichkeit ´ komplexe Datenstrukturen flexibel zu gestalten ` wird bei der Softwareentwicklung zunehmend wertvoller.