Nachrichtensymbol
Zum Fußzeileninhalt springen
  1. IronPDF
  2. IronPDF Blog
  3. .NET Hilfe
  4. C# Linked List
.NET HILFE

C# Linked List (Funktionsweise für Entwickler)

Jacob Mellor, Chief Technology Officer @ Team Iron
Jacob Mellor
Aktualisiert:

Eine verkettete Liste ist eine lineare Datenstruktur, die aus einer Reihe von Knoten besteht, die auch als Elemente bezeichnet werden können. Im Gegensatz zu Arrays, bei denen Elemente/Knoten an aufeinanderfolgenden Speicherorten gespeichert werden, nutzen verkettete Listen die dynamische Speicherzuweisung, sodass Elemente/Knoten über den gesamten Speicher verteilt sein können.

In ihrer einfachsten Form bestehen "verkettete Listen" aus linear miteinander verbundenen Knoten. Jeder Knoten enthält zwei Hauptteile:

  1. Daten: Nutzlast im Knoten gespeichert. Dies kann je nach Implementierung jeder Datentyp sein, wie z. B. Ganzzahlen, Zeichenfolgen, Objekte usw.
  2. Nächster Zeiger: Ein Verweis (oder Zeiger) auf den nächsten Knoten in der Sequenz. Dieser Zeiger zeigt den Speicherort des folgenden Knotens an und zeigt nach vorne in der verketteten Liste.

Der letzte Knoten in einer verketteten Liste zeigt typischerweise auf einen Null-Verweis, was das Ende der Liste anzeigt.

In diesem Artikel werden wir uns die verkettete Liste in C# im Detail ansehen und auch die IronPDF-Bibliothek erkunden, ein PDF-Generierungs-Tool von Iron Software.

Typen von verknüpften Listen

1. Einzeln verknüpfte Liste

Eine einfach verkettete Liste hat einen Knoten mit nur einem Verweis, der typischerweise auf den nächsten Knoten in der Sequenz zeigt. Das Durchlaufen der Liste ist auf die Bewegung in eine Richtung beschränkt, typischerweise vom Kopf (dem ersten Knoten) zum Schwanz (dem letzten Knoten).

2. doppelt verknüpfte Liste

In einer doppelt verketteten Liste enthält jeder Knoten zwei Verweise: einen, der auf den nächsten Knoten und einen weiteren, der auf den vorherigen Knoten in der Sequenz zeigt. Diese bidirektionale Verknüpfung ermöglicht den Durchlauf in beide Richtungen, vorwärts und rückwärts.

3. zirkuläre verknüpfte Liste

In einer zirkulär verketteten Liste zeigt der letzte Knoten zurück auf den ersten Knoten und bildet so eine kreisförmige Struktur. Dieser Typ von verketteter Liste kann entweder mit einfach verketteten oder doppelt verketteten Knoten implementiert werden.

Grundlegende Operationen mit verknüpften Listen

  1. Einfügen: Hinzufügen eines neuen Knotens zur Liste an einer bestimmten Position, wie zum Beispiel am Anfang, Ende oder in der Mitte.
  2. Löschen: Entfernen eines angegebenen Objektknotens aus der Liste und Anpassen der Zeiger der benachbarten Knoten entsprechend.
  3. Durchlauf: Iterieren durch die Liste, um die Daten jedes Knotens zuzugreifen oder zu manipulieren.
  4. Suche: Finden eines bestimmten Knotens in der Liste basierend auf dem daten-spezifizierten Wert.

Linked List in C#

In C# können Sie eine verkettete Liste unter Verwendung der LinkedList-Klasse aus dem System.Collections.Generic-Namespace implementieren. Hier ist ein Beispiel für alle grundlegenden Operationen:

using System;
using System.Collections.Generic;

namespace CsharpSamples
{
    public class Program
    {
        public static void Main()
        {
            // Create a new linked list of integers
            LinkedList<int> linkedList = new LinkedList<int>();

            // Add elements to the linked list
            linkedList.AddLast(10);
            linkedList.AddLast(20);
            linkedList.AddLast(30);
            linkedList.AddLast(40);

            // Traverse and print the elements of the linked list
            Console.WriteLine("Traverse Linked List elements:");
            foreach (var item in linkedList)
            {
                Console.WriteLine(item);
            }

            // Display number of linked list elements
            Console.WriteLine($"Number of Linked List elements: {linkedList.Count}");

            // Find/Search for an element in the linked list
            Console.WriteLine("\nFind/Search Element Linked List elements: 30");
            var foundNode = linkedList.Find(30);

            if (foundNode != null)
            {
                Console.WriteLine(
                    $"Found Value: {foundNode.Value}, " +
                    $"Next Element: {(foundNode.Next != null ? foundNode.Next.Value.ToString() : "null")}, " +
                    $"Previous Element: {(foundNode.Previous != null ? foundNode.Previous.Value.ToString() : "null")}"
                );
            }

            // Insert an element at a specified node
            LinkedListNode<int> current = linkedList.Find(20);
            if (current != null)
            {
                linkedList.AddAfter(current, 25);
            }

            Console.WriteLine($"\nNumber of Linked List elements: {linkedList.Count}");
            Console.WriteLine("\nLinked List elements after insertion:");
            foreach (var item in linkedList)
            {
                Console.WriteLine(item);
            }

            // Remove an existing node from the linked list
            linkedList.Remove(30);

            Console.WriteLine("\nLinked List elements after removal:");
            foreach (var item in linkedList)
            {
                Console.WriteLine(item);
            }

            Console.WriteLine($"\nNumber of Linked List elements: {linkedList.Count}");
        }
    }
}
using System;
using System.Collections.Generic;

namespace CsharpSamples
{
    public class Program
    {
        public static void Main()
        {
            // Create a new linked list of integers
            LinkedList<int> linkedList = new LinkedList<int>();

            // Add elements to the linked list
            linkedList.AddLast(10);
            linkedList.AddLast(20);
            linkedList.AddLast(30);
            linkedList.AddLast(40);

            // Traverse and print the elements of the linked list
            Console.WriteLine("Traverse Linked List elements:");
            foreach (var item in linkedList)
            {
                Console.WriteLine(item);
            }

            // Display number of linked list elements
            Console.WriteLine($"Number of Linked List elements: {linkedList.Count}");

            // Find/Search for an element in the linked list
            Console.WriteLine("\nFind/Search Element Linked List elements: 30");
            var foundNode = linkedList.Find(30);

            if (foundNode != null)
            {
                Console.WriteLine(
                    $"Found Value: {foundNode.Value}, " +
                    $"Next Element: {(foundNode.Next != null ? foundNode.Next.Value.ToString() : "null")}, " +
                    $"Previous Element: {(foundNode.Previous != null ? foundNode.Previous.Value.ToString() : "null")}"
                );
            }

            // Insert an element at a specified node
            LinkedListNode<int> current = linkedList.Find(20);
            if (current != null)
            {
                linkedList.AddAfter(current, 25);
            }

            Console.WriteLine($"\nNumber of Linked List elements: {linkedList.Count}");
            Console.WriteLine("\nLinked List elements after insertion:");
            foreach (var item in linkedList)
            {
                Console.WriteLine(item);
            }

            // Remove an existing node from the linked list
            linkedList.Remove(30);

            Console.WriteLine("\nLinked List elements after removal:");
            foreach (var item in linkedList)
            {
                Console.WriteLine(item);
            }

            Console.WriteLine($"\nNumber of Linked List elements: {linkedList.Count}");
        }
    }
}
$vbLabelText   $csharpLabel

Code-Erklärung

  1. Erstellen Sie eine neue verkettete Liste von Ganzzahlen mit new LinkedList<int>().
  2. Fügen Sie bestimmte Wertobjekte zur verketteten Liste hinzu.
  3. Durchlaufen und Drucken der Elemente der verketteten Liste mit einer foreach-Schleife.
  4. Finden/Suchen Sie ein Element in der verketteten Liste.
  5. Fügen Sie ein Element an einem bestimmten Knoten unter Verwendung der Find- und AddAfter-Methoden ein.
  6. Entfernen Sie einen bestehenden Knoten aus der verketteten Liste mit der Remove-Methode.

Ausgabe

C# Linked List (Wie es für Entwickler funktioniert): Abbildung 1 - Ausgabe der verketteten Liste

Einführung in IronPDF

Entdecken Sie mehr über IronPDF, eine leistungsstarke C# PDF-Bibliothek, entwickelt und gepflegt von Iron Software. Sie bietet eine umfassende Reihe von Funktionen zum Erstellen, Bearbeiten und Extrahieren von Inhalten aus PDF-Dokumenten in .NET-Projekten.

Wichtige Punkte über IronPDF

HTML-zu-PDF-Konvertierung

IronPDF ermöglicht die Konvertierung von HTML-Inhalten in PDF-Format. Sie können HTML-Seiten, URLs und HTML-Zeichenfolgen mit Leichtigkeit in PDFs rendern.

Reiche API

Die Bibliothek bietet eine benutzerfreundliche API, mit der Entwickler professionelle PDFs direkt aus HTML generieren können. Egal, ob Sie Rechnungen, Berichte oder andere Dokumente erstellen müssen, IronPDF vereinfacht den Prozess.

Plattformübergreifende Unterstützung

IronPDF ist mit verschiedenen .NET-Umgebungen kompatibel, einschließlich .NET Core, .NET Standard und .NET Framework. Es läuft auf Windows-, Linux- und macOS-Plattformen.

Vielseitigkeit

IronPDF unterstützt verschiedene Projekttypen, wie Webanwendungen (Blazor und WebForms), Desktopanwendungen (WPF und MAUI) und Konsolenanwendungen.

Inhaltsquellen

Sie können PDFs aus verschiedenen Inhaltsquellen generieren, einschließlich HTML-Dateien, Razor-Ansichten (Blazor-Server), CSHTML (MVC und Razor), ASPX (WebForms) und XAML (MAUI).

Zusätzliche Funktionen

  1. Fügen Sie PDFs Kopf- und Fußzeilen hinzu.
  2. PDF-Seiten zusammenführen, teilen, hinzufügen, kopieren und löschen.
  3. Passwörter, Berechtigungen und digitale Signaturen festlegen.
  4. Leistung optimieren mit Multithreading und asynchroner Unterstützung.

Kompatibilität

IronPDF hält sich an PDF-Standards, einschließlich Versionen 1.2 bis 1.7, PDF/UA und PDF/A. Es unterstützt auch UTF-8-Zeichenkodierung, Basis-URLs und Asset-Kodierung.

PDF-Dokument mit LinkedList erzeugen

Lassen Sie uns nun ein PDF-Dokument mit IronPDF erstellen und die Verwendung von LinkedList-Strings demonstrieren.

Öffnen Sie zunächst Visual Studio und erstellen Sie eine Konsolenanwendung, indem Sie aus Projektschablonen wie unten gezeigt auswählen.

C# Linked List (Wie es für Entwickler funktioniert): Abbildung 2 - Neues Projekt

Geben Sie einen Projektnamen und einen Speicherort an.

C# Linked List (Wie es für Entwickler funktioniert): Abbildung 3 - Projektkonfiguration

Wählen Sie die erforderliche .NET-Version aus.

C# Linked List (Wie es für Entwickler funktioniert): Abbildung 4 - Ziel-Framework

Installieren Sie IronPDF über den Visual Studio-Paketmanager wie unten gezeigt.

C# Linked List (Wie es für Entwickler funktioniert): Abbildung 5 - Installieren von IronPDF

Oder es kann mit dem untenstehenden Befehlszeilenbefehl installiert werden.

dotnet add package IronPdf --version 2024.4.2

Fügen Sie den folgenden Code hinzu.

using System;
using System.Collections.Generic;
using IronPdf;

namespace CsharpSamples
{
    public class Program
    {
        public static void Main()
        {
            var content = "<h1>Demonstrate IronPDF with C# LinkedList</h1>";
            content += "<h2>Create a new linked list of strings</h2>";
            content += "<p>Create a new linked list of strings with new LinkedList&lt;string&gt;()</p>";

            // Create a new linked list of strings
            LinkedList<string> linkedList = new LinkedList<string>();

            // Add elements to the linked list
            content += "<p>Add Apple to linkedList</p>";
            linkedList.AddLast("Apple");

            content += "<p>Add Banana to linkedList</p>";
            linkedList.AddLast("Banana");

            content += "<p>Add Orange to linkedList</p>";
            linkedList.AddLast("Orange");

            content += "<h2>Print the elements of the linked list</h2>";
            Console.WriteLine("Linked List elements:");

            foreach (var item in linkedList)
            {
                content += $"<p>{item}</p>";
                Console.WriteLine(item);
            }

            content += "<h2>Insert an element at a specific position</h2>";
            LinkedListNode<string> node = linkedList.Find("Banana");
            if (node != null)
            {
                linkedList.AddAfter(node, "Mango");
                content += "<p>Find Banana and insert Mango After</p>";
            }

            Console.WriteLine("\nLinked List elements after insertion:");
            content += "<h2>Linked List elements after insertion:</h2>";

            foreach (var item in linkedList)
            {
                content += $"<p>{item}</p>";
                Console.WriteLine(item);
            }

            content += "<h2>Remove an element from the linked list</h2>";
            linkedList.Remove("Orange");
            content += "<p>Remove Orange from linked list</p>";

            Console.WriteLine("\nLinked List elements after removal:");
            content += "<h2>Linked List elements after removal:</h2>";

            foreach (var item in linkedList)
            {
                content += $"<p>{item}</p>";
                Console.WriteLine(item);
            }

            // Create a PDF renderer
            var renderer = new ChromePdfRenderer();

            // Create a PDF from HTML string
            var pdf = renderer.RenderHtmlAsPdf(content);

            // Save to a file
            pdf.SaveAs("AwesomeIronOutput.pdf");
        }
    }
}
using System;
using System.Collections.Generic;
using IronPdf;

namespace CsharpSamples
{
    public class Program
    {
        public static void Main()
        {
            var content = "<h1>Demonstrate IronPDF with C# LinkedList</h1>";
            content += "<h2>Create a new linked list of strings</h2>";
            content += "<p>Create a new linked list of strings with new LinkedList&lt;string&gt;()</p>";

            // Create a new linked list of strings
            LinkedList<string> linkedList = new LinkedList<string>();

            // Add elements to the linked list
            content += "<p>Add Apple to linkedList</p>";
            linkedList.AddLast("Apple");

            content += "<p>Add Banana to linkedList</p>";
            linkedList.AddLast("Banana");

            content += "<p>Add Orange to linkedList</p>";
            linkedList.AddLast("Orange");

            content += "<h2>Print the elements of the linked list</h2>";
            Console.WriteLine("Linked List elements:");

            foreach (var item in linkedList)
            {
                content += $"<p>{item}</p>";
                Console.WriteLine(item);
            }

            content += "<h2>Insert an element at a specific position</h2>";
            LinkedListNode<string> node = linkedList.Find("Banana");
            if (node != null)
            {
                linkedList.AddAfter(node, "Mango");
                content += "<p>Find Banana and insert Mango After</p>";
            }

            Console.WriteLine("\nLinked List elements after insertion:");
            content += "<h2>Linked List elements after insertion:</h2>";

            foreach (var item in linkedList)
            {
                content += $"<p>{item}</p>";
                Console.WriteLine(item);
            }

            content += "<h2>Remove an element from the linked list</h2>";
            linkedList.Remove("Orange");
            content += "<p>Remove Orange from linked list</p>";

            Console.WriteLine("\nLinked List elements after removal:");
            content += "<h2>Linked List elements after removal:</h2>";

            foreach (var item in linkedList)
            {
                content += $"<p>{item}</p>";
                Console.WriteLine(item);
            }

            // Create a PDF renderer
            var renderer = new ChromePdfRenderer();

            // Create a PDF from HTML string
            var pdf = renderer.RenderHtmlAsPdf(content);

            // Save to a file
            pdf.SaveAs("AwesomeIronOutput.pdf");
        }
    }
}
$vbLabelText   $csharpLabel

Code-Erklärung

  1. Zuerst beginnen wir mit der Erstellung des Inhalts für das PDF mithilfe eines Inhaltszeichenfolgenobjekts. Der Inhalt wird als HTML-Zeichenfolge generiert.
  2. Erstellen Sie eine neue verkettete Liste von Strings mit new LinkedList<string>().
  3. Fügen Sie der verketteten Liste Elemente hinzu und hängen Sie auch Informationen an die PDF-Inhaltszeichenfolge an.
  4. Drucken Sie die Elemente der verketteten Liste und fügen Sie sie dem PDF-Inhalt hinzu.
  5. Fügen Sie ein Element an einer bestimmten Position mit der AddAfter-Methode ein; 6. Entfernen Sie ein Element aus der verketteten Liste mit der Remove-Methode und drucken Sie die Liste.
  6. Entfernen Sie ein Element aus der verketteten Liste mit der Remove-Methode, aktualisieren Sie den Inhalt und drucken Sie die resultierende Liste.
  7. Speichern Sie schließlich den generierten HTML-Inhaltsstring in einem PDF-Dokument mit den ChromePdfRenderer, RenderHtmlAsPdf und SaveAs-Methoden.

Ausgabe

C# Linked List (Wie es für Entwickler funktioniert): Abbildung 6 - IronPDF mit `LinkedList`-Ausgabe

Die Ausgabe hat ein Wasserzeichen, das mit einer gültigen Lizenz von der IronPDF Lizenzseite entfernt werden kann.

IronPDF-Lizenz

Die IronPDF-Bibliothek benötigt eine Lizenz, um zu funktionieren, die von der Produktlizenzierungsseite bezogen werden kann.

Fügen Sie den Schlüssel in die Datei appSettings.json unten ein.

{
  "IronPdf.License.LicenseKey": "The Key Goes Here"
}

Abschluss

C# LinkedList bietet eine vielseitige Datenstruktur zur Verwaltung von Elemementsammlungen, die effiziente Einfügungen und Löschungen ermöglicht, während sie eine dynamische Größenanpassung wie die Standard-Hash-Funktion zulässt. Verkettete Listen werden häufig in verschiedenen Anwendungen und Algorithmen verwendet, wie zum Beispiel beim Implementieren von Stapeln, Warteschlangen, Symboltabellen und Speichermanagementsystemen. Das Verständnis der Merkmale und Operationen von verketteten Listen ist entscheidend für den Aufbau effizienter und skalierbarer Softwarelösungen.

Zusammenfassend lässt sich sagen, dass verkettete Listen in bestimmten Szenarien hervorragend abschneiden, wie bei dynamischen Datenstrukturen und häufigen Einfügungen/Löschungen, jedoch möglicherweise nicht die beste Wahl für Anwendungen sind, die häufigen Zufallszugriff erfordern oder mit speicherbeschränkten Umgebungen zu tun haben. Die IronPDF-Bibliothek von Iron Software ermöglicht Entwicklern das einfache Erstellen und Manipulieren von PDF-Dokumenten und fördert fortgeschrittene Fähigkeiten zur Entwicklung moderner Anwendungen.

Die IronPDF-Bibliothek von Iron Software ermöglicht es Entwicklern, mühelos PDF-Dokumente zu erstellen und zu bearbeiten, wodurch fortgeschrittene Fähigkeiten zur Entwicklung moderner Anwendungen ermöglicht werden.

Häufig gestellte Fragen

Was ist eine verkettete Liste in C#?

Eine verkettete Liste in C# ist eine lineare Datenstruktur, die aus Knoten besteht, wobei jeder Knoten Daten und eine Referenz auf den nächsten Knoten enthält. Diese Struktur ermöglicht im Gegensatz zu Arrays eine dynamische Speicherzuweisung, wodurch Elemente in nicht zusammenhängenden Speicherorten gespeichert werden können.

Wie kann ich HTML in PDF in C# konvertieren?

Sie können die RenderHtmlAsPdf-Methode von IronPDF verwenden, um HTML-Strings in PDFs zu konvertieren. Es ermöglicht auch die Konvertierung von HTML-Dateien in PDFs mit RenderHtmlFileAsPdf.

Was sind die Typen von verketteten Listen in C#?

In C# sind die Haupttypen von verketteten Listen einfach verkettete Listen, doppelt verkettete Listen und zirkuläre verkettete Listen. Einfach verkettete Listen verfügen über Knoten mit einer einzigen Referenz auf den nächsten Knoten, doppelt verkettete Listen haben Referenzen sowohl auf den nächsten als auch auf den vorherigen Knoten, und zirkuläre verkettete Listen haben den letzten Knoten, der auf den ersten Knoten zeigt.

Welche grundlegenden Operationen gibt es für verkettete Listen?

Verkettete Listen unterstützen Operationen wie Einfügen (Hinzufügen eines neuen Knotens), Löschen (Entfernen eines vorhandenen Knotens), Durchlauf (Iterieren durch die Liste) und Suche (Finden eines Knotens basierend auf seinen Daten).

Wie implementiert man eine verkettete Liste in C#?

Eine verkettete Liste kann in C# mit der LinkedList-Klasse aus dem System.Collections.Generic-Namespace implementiert werden, die Methoden zum Hinzufügen, Entfernen und Manipulieren der Knoten in der Liste bereitstellt.

Welche Funktionen bietet eine PDF-Generierungsbibliothek?

Eine PDF-Generierungsbibliothek wie IronPDF bietet HTML-zu-PDF-Konvertierung, Textextraktion, Dokumentenzusammenführung und -trennung sowie das Setzen von Dokumentenberechtigungen, alles innerhalb verschiedener .NET-Umgebungen.

Wie können verkettete Listen mit der PDF-Generierung verwendet werden?

Verkettete Listen können dynamisch Inhalte speichern und organisieren, die dann iteriert und mithilfe einer Bibliothek wie IronPDF in ein PDF-Dokument umgewandelt werden können, was die Inhaltsmanipulation und -ausgabe erleichtert.

Welche Vorteile bieten verkettete Listen in der Softwareentwicklung?

Verkettete Listen bieten effiziente Einfügungen und Löschungen, dynamische Größeneinstellung und sind vorteilhaft für die Implementierung dynamischer Datenstrukturen wie Stacks und Warteschlangen. Sie sind besonders nützlich, wenn häufige Änderungen erforderlich sind, obwohl ihnen die Fähigkeit zum direkten Zugriff fehlt.

Was ist der Unterschied zwischen einfach und doppelt verketteten Listen?

Der Hauptunterschied besteht darin, dass einfach verkettete Listen Knoten mit einer einzigen Referenz auf den nächsten Knoten haben, was eine einseitige Durchlaufung ermöglicht, während doppelt verkettete Listen Knoten mit Referenzen sowohl auf den nächsten als auch auf den vorherigen Knoten haben, was eine bidirektionale Durchlaufung ermöglicht.

Wie kann ich ein PDF aus verketteten Listendaten in C# generieren?

Sie können durch die verkettete Liste iterieren, um Daten zu sammeln, und dann die API von IronPDF verwenden, um diese Daten in ein PDF-Dokument zu rendern. Dies beinhaltet die Nutzung von Methoden wie HtmlToPdf, um strukturierte Inhalte in ein professionelles PDF-Format umzuwandeln.

Jacob Mellor, Chief Technology Officer @ Team Iron
Jacob Mellor
  Jetzt mit dem Ingenieurteam chatten
Chief Technology Officer

Jacob Mellor ist Chief Technology Officer bei Iron Software und ein visionärer Ingenieur, der Pionierarbeit in der C# PDF-Technologie leistet. Als der ursprüngliche Entwickler hinter der Kern-Codebasis von Iron Software hat er die Produktarchitektur des Unternehmens seit seiner Gründung geprägt und es zusammen mit CEO ...

Weiterlesen

Verwandte Artikel

30-Tage-Testversion → Volles Produkt. Keine Grenzen. Keine Karte. Gratis testen

Iron Support Team

We're online 24 hours, 5 days a week.
Chat
Email
Call Me