C# Linked List (Wie es funktioniert für Entwickler)

Eine verknüpfte 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 zusammenhängenden Speicherplätzen gespeichert werden, verwenden verknüpfte Listen eine dynamische Speicherzuweisung, so dass Elemente/Knoten über den gesamten Speicher verstreut werden können.

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

1. Daten: Im Knoten gespeicherte Nutzdaten. Dies kann je nach Implementierung ein beliebiger Datentyp sein, z. B. Ganzzahlen, Strings, Objekte usw.

2. Nächster Zeiger: Eine Referenz(oder Zeiger) zum nächsten Knoten in der Sequenz. Dieser Zeiger gibt die Speicherposition des nächsten Knotens an, der in der verknüpften Liste nach vorne zeigt.

   Der letzte Knoten in einer verknüpften Liste zeigt normalerweise auf eine Null-Referenz, die das Ende der Liste anzeigt.

   In diesem Artikel werden wir uns die Linked List in C# im Detail ansehen und auch dieIronPDF-Bibliothekein PDF-Generierungswerkzeug vonIron Software.

Arten von verknüpften Listen

1. Einzeln verknüpfte Liste

Eine einfach verknüpfte Liste hat einen Knoten mit nur einem Verweis, der normalerweise auf den nächsten Knoten in der Sequenz verweist. Das Durchlaufen der Liste ist auf eine Richtung beschränkt, in der Regel vom Kopf(der Anfangsknoten) zum Schwanz(der Endknoten).

2. Doppelt verknüpfte Liste

In einer doppelt verknüpften Liste enthält jeder Knoten zwei Verweise: einen, der auf den nächsten Knoten verweist, und einen weiteren, der auf den vorherigen Knoten in der Folge verweist. Diese bidirektionale Verknüpfung ermöglicht die Durchquerung sowohl in Vorwärts- als auch in Rückwärtsrichtung.

3. Zirkuläre Verknüpfte Liste

In einer zirkulär verknüpften Liste verweist der letzte Knoten zurück auf den ersten Knoten und bildet so eine zirkuläre Struktur. Diese Art der verknüpften Liste kann entweder mit einfach oder doppelt verknüpften Knoten implementiert werden.

Grundlegende Operationen mit verknüpften Listen

1. Einfügen: Hinzufügen eines neuen Knotens zur Liste an einer bestimmten Stelle, z. B. am Anfang, am Ende oder in der Mitte.

2. Löschung: Entfernen eines bestimmten Objektknotens aus der Liste und entsprechendes Anpassen der Zeiger auf benachbarte Knoten.

3. Traversal: Iterieren durch die Liste, um auf die Daten der einzelnen Knoten zuzugreifen oder sie zu bearbeiten.

4. Suchen: Auffinden eines bestimmten Knotens in der Liste auf der Grundlage seines datenbezogenen Wertes.

Verknüpfte Liste in C##

In C# können Sie eine verknüpfte Liste mit der MethodelinkedList klasse aus dem Namespace System.Collections.Generic. Hier ist ein Beispiel für alle grundlegenden Vorgänge:

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 which create objects from node class
            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);
            }
            Console.WriteLine($"Number of Linked List elements:{linkedList.Count}"); // use count property to display length
            // Find/Search Element in Linked List
            Console.WriteLine("\nFind/Search Element Linked List elements: 30");
            var foundNode = linkedList.Find(30);// method returns the node
            Console.WriteLine($"Found Value:{foundNode.Value}, Next Element:{foundNode.Next.Value}, Previous Element:{foundNode.Previous.Value}"); // prints next node, previous node
            // Insert an element at a specified node
            LinkedListNode<int> current = linkedList.Find(20);
            linkedList.AddAfter(current, 25);
            Console.WriteLine($"\nNumber of Linked List elements:{linkedList.Count}"); // use count property to display length
            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); // remove current node
            Console.WriteLine("\nLinked List elements after removal:");
            foreach (var item in linkedList)
            {
                Console.WriteLine(item);
            }
            Console.WriteLine($"\nNumber of Linked List elements:{linkedList.Count}"); // use count property to display length
        }
    }
}

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 which create objects from node class
            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);
            }
            Console.WriteLine($"Number of Linked List elements:{linkedList.Count}"); // use count property to display length
            // Find/Search Element in Linked List
            Console.WriteLine("\nFind/Search Element Linked List elements: 30");
            var foundNode = linkedList.Find(30);// method returns the node
            Console.WriteLine($"Found Value:{foundNode.Value}, Next Element:{foundNode.Next.Value}, Previous Element:{foundNode.Previous.Value}"); // prints next node, previous node
            // Insert an element at a specified node
            LinkedListNode<int> current = linkedList.Find(20);
            linkedList.AddAfter(current, 25);
            Console.WriteLine($"\nNumber of Linked List elements:{linkedList.Count}"); // use count property to display length
            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); // remove current node
            Console.WriteLine("\nLinked List elements after removal:");
            foreach (var item in linkedList)
            {
                Console.WriteLine(item);
            }
            Console.WriteLine($"\nNumber of Linked List elements:{linkedList.Count}"); // use count property to display length
        }
    }
}

Imports Microsoft.VisualBasic

Namespace CsharpSamples
Public Class Program
	Public Shared Sub Main()
			' Create a new linked list of integers
			Dim linkedList As New LinkedList(Of Integer)()
			' Add elements to the linked list which create objects from node class
			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:")
			For Each item In linkedList
				Console.WriteLine(item)
			Next item
			Console.WriteLine($"Number of Linked List elements:{linkedList.Count}") ' use count property to display length
			' Find/Search Element in Linked List
			Console.WriteLine(vbLf & "Find/Search Element Linked List elements: 30")
			Dim foundNode = linkedList.Find(30) ' method returns the node
			Console.WriteLine($"Found Value:{foundNode.Value}, Next Element:{foundNode.Next.Value}, Previous Element:{foundNode.Previous.Value}") ' prints next node, previous node
			' Insert an element at a specified node
			Dim current As LinkedListNode(Of Integer) = linkedList.Find(20)
			linkedList.AddAfter(current, 25)
			Console.WriteLine($vbLf & "Number of Linked List elements:{linkedList.Count}") ' use count property to display length
			Console.WriteLine(vbLf & "Linked List elements after insertion:")
			For Each item In linkedList
				Console.WriteLine(item)
			Next item
			' Remove an existing node from the linked list 
			linkedList.Remove(30) ' remove current node
			Console.WriteLine(vbLf & "Linked List elements after removal:")
			For Each item In linkedList
				Console.WriteLine(item)
			Next item
			Console.WriteLine($vbLf & "Number of Linked List elements:{linkedList.Count}") ' use count property to display length
	End Sub
End Class
End Namespace

Code Erläuterung

1. Erstellen einer neuen verknüpften Liste von Ganzzahlen mit der neuen LinkedList<int>().

2. Zusätzliche spezifizierte Wertobjekte in einer verknüpften Liste.

3. Durchlaufen und drucken Sie die Elemente der verknüpften Liste mit Hilfe der "Foreach"-Schleife.

4. Ein Element in der verknüpften Liste suchen/finden.

5. Einfügen eines Elements an einem bestimmten Knoten mit den Methoden Find und AddAfter.

6. Entfernen Sie einen vorhandenen Knoten aus der verknüpften Liste mit der Methode Remove.

Ausgabe

Einführung in IronPDF

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

Wichtige Punkte über IronPDF

Konvertierung von HTML in PDF

IronPDF ermöglicht Ihnen die Konvertierung von HTML-Inhalten in das PDF-Format. Sie können HTML-Seiten, URLs und HTML-Zeichenfolgen problemlos in PDFs übertragen.

Reichhaltige API

Die Bibliothek bietet eine benutzerfreundliche API, die es Entwicklern ermöglicht, PDFs in professioneller Qualität direkt aus HTML zu erzeugen. Egal, ob Sie Rechnungen, Berichte oder andere Dokumente erstellen müssen, IronPDF vereinfacht diesen 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, z. B. Webanwendungen(Blazor und WebForms), Desktop-Anwendungen(WPF und MAUI)und Konsolenanwendungen.

Quellen für den Inhalt

Sie können PDFs aus verschiedenen Inhaltsquellen erzeugen, darunter HTML-Dateien, Razor-Ansichten(Blazor Server), CSHTML(MVC und Razor)aSPX(WebForms)und XAML(MAUI).

Zusätzliche Merkmale

1. Hinzufügen von Kopf- und Fußzeilen zu PDFs.

2. PDF-Seiten zusammenführen, teilen, hinzufügen, kopieren und löschen.

3. Legen Sie Passwörter, Berechtigungen und digitale Signaturen fest.

4. Optimieren Sie die Leistung mit Multithreading und asynchroner Unterstützung.

Kompatibilität

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

PDF-Dokument mit LinkedList generieren

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

Öffnen Sie zunächst Visual Studio und erstellen Sie eine Konsolenanwendung, indem Sie eine der unten abgebildeten Projektvorlagen auswählen.

Geben Sie einen Projektnamen und den Standort an.

Wählen Sie die gewünschte .NET-Version aus.

Installieren Sie IronPDF über den Visual Studio-Paketmanager, wie in der folgenden Abbildung gezeigt.

Es kann auch über die unten stehende Befehlszeile installiert werden.

dotnet add package IronPdf --version 2024.4.2

Fügen Sie den folgenden Code ein.

using 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></p>";
            content += "<p>Create a new linked list of strings with new LinkedList<string>()</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>";
            // Print the elements of the linked list
            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>";
            // Insert an element at a specific position
            LinkedListNode<string> node = linkedList.Find("Banana");
            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>";
            // Remove an element from the linked list
            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 Renderer
            var renderer = new ChromePdfRenderer();
            // Create a PDF from HTML string
            var pdf = renderer.RenderHtmlAsPdf(content);
            // Save to a file or Stream
            pdf.SaveAs("AwesomeIronOutput.pdf");        
    }
}

using 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></p>";
            content += "<p>Create a new linked list of strings with new LinkedList<string>()</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>";
            // Print the elements of the linked list
            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>";
            // Insert an element at a specific position
            LinkedListNode<string> node = linkedList.Find("Banana");
            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>";
            // Remove an element from the linked list
            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 Renderer
            var renderer = new ChromePdfRenderer();
            // Create a PDF from HTML string
            var pdf = renderer.RenderHtmlAsPdf(content);
            // Save to a file or Stream
            pdf.SaveAs("AwesomeIronOutput.pdf");        
    }
}

Imports Microsoft.VisualBasic
Imports CsharpSamples
Public Class Program
	Public Shared Sub Main()
			Dim content = "<h1>Demonstrate IronPDF with C# LinkedList</h1>"
			content &= "<h2>Create a new linked list of strings</h2>"
			content &= "<p></p>"
			content &= "<p>Create a new linked list of strings with new LinkedList<string>()</p>"
			' Create a new linked list of strings
			Dim linkedList As New LinkedList(Of 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>"
			' Print the elements of the linked list
			Console.WriteLine("Linked List elements:")
			For Each item In linkedList
				content &= $"<p>{item}</p>"
				Console.WriteLine(item)
			Next item
			content &= "<h2>Insert an element at a specific position</h2>"
			' Insert an element at a specific position
			Dim node As LinkedListNode(Of String) = linkedList.Find("Banana")
			linkedList.AddAfter(node, "Mango")
			content &= "<p>Find Banana and insert Mango After</p>"
			Console.WriteLine(vbLf & "Linked List elements after insertion:")
			content &= "<h2>Linked List elements after insertion:</h2>"
			For Each item In linkedList
				content &= $"<p>{item}</p>"
				Console.WriteLine(item)
			Next item
			content &= "<h2>Remove an element from the linked list</h2>"
			' Remove an element from the linked list
			linkedList.Remove("Orange")
			content &= "<p>Remove Orange from linked list</p>"
			Console.WriteLine(vbLf & "Linked List elements after removal:")
			content &= "<h2>Linked List elements after removal:</h2>"
			For Each item In linkedList
				content &= $"<p>{item}</p>"
				Console.WriteLine(item)
			Next item
			' create Renderer
			Dim renderer = New ChromePdfRenderer()
			' Create a PDF from HTML string
			Dim pdf = renderer.RenderHtmlAsPdf(content)
			' Save to a file or Stream
			pdf.SaveAs("AwesomeIronOutput.pdf")
	End Sub
End Class

Code Erläuterung

1. Zunächst erstellen wir den Inhalt für die PDF-Datei mithilfe eines Content-String-Objekts. Der Inhalt wird als HTML-String erstellt.

2. Erstellen einer neuen verknüpften Liste von Zeichenketten mit einer neuen LinkedList<string>().

3. Fügen Sie der verknüpften Liste und dem PDF-Inhaltsstring Elemente hinzu.

4. Druckt die Elemente der verknüpften Liste.

5. Einfügen eines Elements an einer bestimmten Position mit der Methode AddAfter und Ausdrucken der resultierenden Liste.

6. Entfernen Sie ein Element aus der verknüpften Liste mithilfe der Remove-Methode und geben Sie die resultierende Liste aus.

7. Abschließend speichern Sie den erzeugten HTML-Inhaltsstring mit den Methoden "ChromePdfRenderer", "RenderHtmlAsPdf" und "SaveAs" in einem PDF-Dokument.

Ausgabe

Die Ausgabe ist mit einem Wasserzeichen versehen, das mit einer gültigen Lizenz des Herstellers entfernt werden kannIronPDF-Lizenzierungsseite.

IronPDF-Lizenz

DieDie IronPDF-Bibliothek erfordert eine Lizenz für die Ausführungund kann über die Websiteproduktlizenzierungsseite.

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

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

Schlussfolgerung

C# LinkedList bietet eine vielseitige Datenstruktur für die Verwaltung von Sammlungen von Elementen, die effizientes Einfügen und Löschen ermöglicht und gleichzeitig eine dynamische Größenänderung ähnlich der Standard-Hash-Funktion zulässt. Verknüpfte Listen werden häufig in verschiedenen Anwendungen und Algorithmen verwendet, z. B. bei der Implementierung von Stapeln, Warteschlangen, Symboltabellen und Speicherverwaltungssystemen. Das Verständnis der Merkmale und Operationen von verknüpften Listen ist für die Entwicklung effizienter und skalierbarer Softwarelösungen unerlässlich.

Zusammenfassend lässt sich sagen, dass verknüpfte Listen zwar in bestimmten Szenarien, z. B. bei dynamischen Datenstrukturen und häufigen Einfügungen/Löschungen, hervorragend geeignet sind, aber nicht unbedingt die beste Wahl für Anwendungen sind, die häufigen wahlfreien Zugriff erfordern oder in Umgebungen mit begrenztem Speicherplatz arbeiten. Eine sorgfältige Abwägung der spezifischen Anforderungen und Merkmale der Daten kann die Auswahl der am besten geeigneten Datenstruktur für die jeweilige Aufgabe leiten.

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.