AIDE .NET

Liste chaînée en C# (Comment ça marche pour les développeurs)

Regan Pun

juin 6, 2024

Une liste chaînée est une structure de données linéaire composée d'une série de nœuds, également appelés éléments. Contrairement aux tableaux, dont les éléments/nœuds sont stockés dans des emplacements de mémoire contigus, les listes chaînées utilisent l'allocation dynamique de la mémoire, ce qui permet de disperser les éléments/nœuds dans toute la mémoire.

Dans leur forme la plus simple, les "listes chaînées" sont constituées de nœuds reliés entre eux de manière linéaire. Chaque nœud contient deux parties principales :

Données : Charge utile stockée dans le nœud. Il peut s'agir de n'importe quel type de données en fonction de l'implémentation, comme des entiers, des chaînes de caractères, des objets, etc.
Next Pointer : Une référence(ou pointeur) au nœud suivant de la séquence. Ce pointeur indique l'emplacement en mémoire du nœud suivant dans la liste chaînée.
Le dernier nœud d'une liste chaînée pointe généralement vers une référence nulle, indiquant la fin de la liste.
Dans cet article, nous examinerons en détail la liste liée en C# et nous explorerons également l'outil de traduction en C#Bibliothèque IronPDFun outil de génération de PDF deIron Software.

Types de listes liées

1. Liste chaînée simple

Une liste de liens simples comporte un nœud avec une seule référence, qui pointe généralement vers le nœud suivant dans la séquence. Le déplacement dans la liste est limité à une seule direction, typiquement depuis la tête de liste(le nœud initial) à la queue(le nœud final).

2. Liste doublement liée

Dans une liste doublement chaînée, chaque nœud contient deux références : l'une pointe vers le nœud suivant et l'autre vers le nœud précédent de la séquence. Ce lien bidirectionnel permet d'effectuer des déplacements dans les deux sens, vers l'avant et vers l'arrière.

3. Liste circulaire

Dans une liste chaînée circulaire, le dernier nœud renvoie au premier nœud, formant ainsi une structure circulaire. Ce type de liste chaînée peut être mis en œuvre à l'aide de nœuds simples ou doubles.

Opérations de base sur les listes chaînées

Insertion : Ajout d'un nouveau nœud à la liste à une position spécifique, par exemple au début, à la fin ou au milieu.
Suppression : Suppression d'un nœud d'objet spécifié de la liste et ajustement des pointeurs des nœuds voisins en conséquence.
Traversal : Itération dans la liste pour accéder aux données de chaque nœud ou les manipuler.
Recherche : Recherche d'un nœud spécifique dans la liste sur la base de sa valeur spécifiée dans les données.

Liste chaînée en C# ;

En C#, vous pouvez mettre en œuvre une liste chaînée à l'aide de la fonctionListeLiée de l'espace de noms System.Collections.Generic. Voici un exemple de toutes les opérations de base :

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

Explication du code

Créer une nouvelle liste chaînée d'entiers en utilisant la nouvelle LinkedList<int>().
Ajout d'objets à valeur spécifiée à une liste chaînée.
Parcourez et imprimez les éléments de la liste chaînée à l'aide de la boucle foreach.
Trouver/rechercher un élément dans la liste chaînée.
Insérer un élément à un nœud spécifié en utilisant les méthodes Find et AddAfter.
Supprimez un nœud existant de la liste chaînée à l'aide de la méthode Remove.

Sortie

Liste chaînée en C# (Comment ça marche pour les développeurs) : Figure 1 - Sortie d'une liste chaînée

Présentation d'IronPDF

En savoir plus sur IronPDF est une puissante bibliothèque PDF en C# développée et maintenue par Iron Software. Il offre un ensemble complet de fonctionnalités permettant de créer, d'éditer et d'extraire le contenu de documents PDF dans le cadre de projets .NET.

Points clés à propos d'IronPDF

Conversion de HTML en PDF

IronPDF vous permet de convertir du contenu HTML au format PDF. Vous pouvez facilement convertir des pages HTML, des URL et des chaînes HTML en PDF.

Une API riche

La bibliothèque offre une API conviviale qui permet aux développeurs de générer des PDF de qualité professionnelle directement à partir de HTML. Que vous ayez besoin de créer des factures, des rapports ou d'autres documents, IronPDF simplifie le processus.

Support multiplateforme

IronPDF est compatible avec différents environnements .NET, notamment .NET Core, .NET Standard et .NET Framework. Il fonctionne sur les plateformes Windows, Linux et macOS.

Polyvalence

IronPDF prend en charge différents types de projets, tels que les applications web(Blazor et WebForms)applications de bureau, applications de bureau(WPF et MAUI)et les applications sur console.

Sources de contenu

Vous pouvez générer des PDF à partir de diverses sources de contenu, notamment des fichiers HTML, des vues Razor(Serveur Blazor)cSHTML(MVC et Razor)aSPX(WebForms)et XAML(MAUI).

Caractéristiques supplémentaires

Ajouter des en-têtes et des pieds de page aux PDF.
Fusionner, diviser, ajouter, copier et supprimer des pages PDF.
Définir des mots de passe, des autorisations et des signatures numériques.
Optimisez les performances grâce à la prise en charge du multithreading et de l'asynchronisme.

Compatibilité

IronPDF respecte les normes PDF, notamment les versions 1.2 à 1.7, PDF/UA et PDF/A. Il prend également en charge le codage des caractères UTF-8, les URL de base et le codage des actifs.

Générer un document PDF à l'aide de `LinkedList` (liste de liens)

Créons maintenant un document PDF à l'aide d'IronPDF et démontrons également l'utilisation des chaînes LinkedList.

Pour commencer, ouvrez Visual Studio et créez une application console en choisissant parmi les modèles de projet comme indiqué ci-dessous.

Liste chaînée en C# (Comment ça marche pour les développeurs) : Figure 2 - Nouveau projet

Indiquez le nom et la localisation du projet.

Liste chaînée C# (Comment ça marche pour les développeurs) : Figure 3 - Configuration du projet

Sélectionnez la version .NET requise.

Liste chaînée en C# (Comment ça marche pour les développeurs) : Figure 4 - Cadre cible

Installez IronPDF à partir du gestionnaire de paquets de Visual Studio comme ci-dessous.

Liste chaînée en C# (Comment ça marche pour les développeurs) : Figure 5 - Installer IronPDF

Il peut également être installé à l'aide de la ligne de commande ci-dessous.

dotnet add package IronPdf --version 2024.4.2

Ajoutez le code ci-dessous.

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

Explication du code

Nous commençons par créer le contenu du PDF à l'aide d'un objet de type chaîne de contenu. Le contenu est créé sous la forme d'une chaîne HTML.
Créer une nouvelle liste chaînée de chaînes de caractères avec une nouvelle LinkedList<string>().
Ajouter des éléments à la liste liée et à la chaîne de contenu du PDF.
Imprime les éléments de la liste chaînée.
Insérez un élément à une position spécifique à l'aide de la méthode AddAfter et imprimez la liste résultante.
Retirez un élément de la liste chaînée à l'aide de la méthode Remove et imprimez la liste obtenue.
Enfin, enregistrez la chaîne de contenu HTML générée dans un document PDF à l'aide des méthodes ChromePdfRenderer, RenderHtmlAsPdf et SaveAs.

Sortie

Liste chaînée C#(Comment ça marche pour les développeurs) : Figure 6 - IronPDF avec sortie `LinkedList`

Le résultat comporte un filigrane qui peut être supprimé à l'aide d'une licence valide de l'associationPage de licences IronPDF.

Licence d'IronPDF

LesLa bibliothèque IronPDF nécessite une licence pour fonctionnerles traductions sont disponibles sur le site web de la Commission européenne et peuvent être obtenues auprès de la Commission européennepage sur les licences de produits.

Collez la clé dans le fichier appSettings.json ci-dessous.

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

Conclusion

C# LinkedList fournit une structure de données polyvalente pour gérer des collections d'éléments, offrant des insertions et des suppressions efficaces tout en s'adaptant à un redimensionnement dynamique similaire à la fonction de hachage par défaut. Les listes chaînées sont couramment utilisées dans diverses applications et algorithmes, notamment pour la mise en œuvre de piles, de files d'attente, de tables de symboles et de systèmes de gestion de la mémoire. Il est essentiel de comprendre les caractéristiques et les opérations des listes chaînées pour élaborer des solutions logicielles efficaces et évolutives.

En résumé, si les listes chaînées excellent dans certains scénarios, tels que les structures de données dynamiques et les insertions/délétions fréquentes, elles ne constituent pas nécessairement le meilleur choix pour les applications nécessitant un accès aléatoire fréquent ou pour les environnements à mémoire limitée. Un examen attentif des exigences et des caractéristiques spécifiques des données peut guider la sélection de la structure de données la plus appropriée pour la tâche à accomplir.

La bibliothèque IronPDF d'Iron Software permet aux développeurs de créer et de manipuler des documents PDF sans effort, ce qui permet d'acquérir des compétences avancées pour développer des applications modernes.

Regan Pun

Discutez avec l'équipe d'ingénierie maintenant

Ingénieur logiciel

Regan est diplômé de l'université de Reading, où il a obtenu une licence en ingénierie électronique. Avant de rejoindre Iron Software, il s'était concentré sur une seule tâche. Ce qu'il apprécie le plus chez Iron Software, c'est la diversité des tâches qu'il peut accomplir, qu'il s'agisse d'apporter une valeur ajoutée aux ventes, à l'assistance technique, au développement de produits ou à la commercialisation. Il aime comprendre comment les développeurs utilisent la bibliothèque d'Iron Software et utiliser ces connaissances pour améliorer continuellement la documentation et développer les produits.

< PRÉCÉDENT
Chaîne inversée en C# (Comment ça marche pour les développeurs)

SUIVANT >
C# iList (Comment ça marche pour les développeurs)