Implementierung einer verketteten Liste mit C#

Eine verkettete Liste ist eine Datenstruktur die aus einer Sammlung von Elementen besteht, obwohl dabei jedes Element eine Referenz auf das nächste Element in der Liste enthält. In C# kann eine verkettete Liste mit einer verknüpften Klasse erstellt werden, die welche Daten und Verweise auf das nächste und vorherige Element enthält. Um eine verkettete Liste implementation zu erstellen, können folgende Schritte befolgt werden:

1. Erstellen Sie eine Klasse – um die Listenelemente zu repräsentieren. Diese Klasse sollte ein Feld haben ´ um die Daten des Elements zu speichern ` und ebenfalls Verweise auf das nächste und vorherige Element in der Liste.

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

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

2. Erstellen Sie eine Klasse – um die verkettete Liste selbst zu repräsentieren. Diese Klasse sollte Methoden zum Hinzufügen von Elementen am Anfang und Ende der Liste ´ zum Entfernen von Elementen ` zum Durchlaufen der Liste in beide Richtungen und zur Ausgabe der Liste enthalten.

```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;
}
}
}
```

3. Um die verkettete Liste zu verwenden, können Sie eine Instanz der `VerketteteListe`-Klasse erstellen und Elemente hinzufügen, entfernen oder die Liste ausgeben.

```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
```

Mit dieser Implementierung können Sie eine verkettete Liste in C# erstellen und sowie vorwärts als auch rückwärts durchlaufen. Sie können Elemente am Anfang oder Ende der Liste hinzufügen oder entfernen und die Liste ausgeben.