AYUDA .NET

C# Linked List (Cómo funciona para desarrolladores)

Name: IronPDF
Brand: Iron Software
Availability: InStock
Rating: 4.87 (307 reviews)

Chipego Kalinda

6 de junio, 2024

Una lista enlazada es una estructura de datos lineal compuesta por una serie de nodos, que también pueden denominarse elementos. A diferencia de las matrices, en las que los elementos/nodos se almacenan en ubicaciones de memoria contiguas, las listas enlazadas utilizan la asignación dinámica de memoria, lo que permite que los elementos/nodos estén dispersos por toda la memoria.

En su forma más simple, las "listas enlazadas" están formadas por nodos enlazados linealmente. Cada nodo contiene dos partes principales:

Datos: Carga útil almacenada en el nodo. Puede ser de cualquier tipo de datos dependiendo de la implementación, como enteros, cadenas, objetos, etc.
Siguiente Puntero: Una referencia (o puntero) al siguiente nodo en la secuencia. Este puntero indica la ubicación de memoria del siguiente nodo apunta hacia adelante en la lista enlazada.
El último nodo de una lista enlazada suele apuntar a una referencia nula, indicando el final de la lista.
En este artículo, examinaremos en detalle la lista enlazada en C# y también exploraremos la biblioteca IronPDF, una herramienta de generación de PDF de Iron Software.

Tipos de listas enlazadas

1. Lista enlazada simple

Una lista enlazada tiene un nodo con una sola referencia, que normalmente apunta al siguiente nodo de la secuencia. El recorrido de la lista está limitado a moverse en una dirección, generalmente desde el inicio (el nodo inicial) hasta el final (el nodo final).

2. Lista doblemente enlazada

En una lista doblemente enlazada, cada nodo contiene dos referencias: una que apunta al nodo siguiente y otra que apunta al nodo anterior de la secuencia. Esta conexión bidireccional permite avanzar y retroceder.

3. Lista enlazada circular

En una lista circular enlazada, el último nodo vuelve a apuntar al primero, formando una estructura circular. Este tipo de lista enlazada puede implementarse utilizando nodos simple o doblemente enlazados.

Operaciones básicas con listas enlazadas

Inserción: Añadir un nuevo nodo a la lista en una posición específica, como el principio, el final o el medio.
Eliminación: Eliminación de un nodo de objeto especificado de la lista y ajuste de los punteros de los nodos vecinos en consecuencia.
Recorrido: Iterar a través de la lista para acceder o manipular los datos de cada nodo.
Buscar: Encontrar un nodo específico en la lista basado en su valor especificado por los datos.

Lista enlazada en C#

En C#, puedes implementar una lista enlazada utilizando la clase LinkedList del espacio de nombres System.Collections.Generic. Aquí tienes un ejemplo de todas las operaciones básicas:

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

Código Explicación

Crea una nueva lista enlazada de enteros utilizando el nuevo LinkedList<int>().
Objetos de valor especificados adicionales a una lista enlazada.
Recorra e imprima los elementos de la lista enlazada utilizando el bucle foreach.
Encontrar/buscar un elemento en la lista enlazada.
Inserte un elemento en un nodo especificado usando los métodos Find y AddAfter.
Elimina un nodo existente de la lista enlazada utilizando el método Remove.

Salida

Lista Vinculada en C# (Cómo Funciona para Desarrolladores): Figura 1 - Salida de la Lista Vinculada

Presentación de IronPDF

Descubra más sobre IronPDF es una potente biblioteca PDF de C# desarrollada y mantenida por Iron Software. Proporciona un completo conjunto de funciones para crear, editar y extraer contenido de documentos PDF dentro de proyectos .NET.

Puntos clave sobre IronPDF

Conversión de HTML a PDF

IronPDF permite convertir contenidos HTML a formato PDF. Puede convertir páginas HTML, URL y cadenas HTML en PDF con facilidad.

API enriquecida

La biblioteca ofrece una API fácil de usar que permite a los desarrolladores generar PDF de calidad profesional directamente a partir de HTML. Tanto si necesita crear facturas, informes u otros documentos, IronPDF simplifica el proceso.

Soporte multiplataforma

IronPDF es compatible con varios entornos .NET, incluidos .NET Core, .NET Standard y .NET Framework. Funciona en plataformas Windows, Linux y macOS.

Versatilidad

IronPDF admite diferentes tipos de proyectos, como aplicaciones web (Blazor y WebForms), aplicaciones de escritorio (WPF y MAUI) y aplicaciones de consola.

Fuentes de contenido

Puede generar PDFs a partir de diversas fuentes de contenido, incluyendo archivos HTML, vistas Razor (Blazor Server), CSHTML (MVC y Razor), ASPX (WebForms) y XAML (MAUI).

Características adicionales

Añade encabezados y pies de página a los PDF.
Fusione, divida, añada, copie y elimine páginas PDF.
Establezca contraseñas, permisos y firmas digitales.
Optimice el rendimiento con multihilo y soporte asíncrono.

Compatibilidad

IronPDF cumple los estándares PDF, incluidas las versiones 1.2 a 1.7, PDF/UA y PDF/A. También admite codificación de caracteres UTF-8, URL base y codificación de activos.

Generar Documento PDF Usando `LinkedList`

Ahora vamos a crear un documento PDF usando IronPDF y también demostrar el uso de cadenas LinkedList.

Para empezar, abra Visual Studio y cree una aplicación de consola seleccionando una de las plantillas de proyecto que se muestran a continuación.

Lista Enlazada en C# (Cómo Funciona para Desarrolladores): Figura 2 - Nuevo Proyecto

Indique el nombre y la ubicación del proyecto.

Lista enlazada en C# (Cómo funciona para desarrolladores): Figura 3 - Configuración del proyecto

Seleccione la versión .NET necesaria.

Lista enlazada en C# (Cómo funciona para desarrolladores): Figura 4 - Marco de objetivo

Instale IronPDF desde el gestor de paquetes de Visual Studio como el que se muestra a continuación.

Lista enlazada en C# (Cómo funciona para desarrolladores): Figura 5 - Instalar IronPDF

También se puede instalar utilizando la línea de comandos que se indica a continuación.

dotnet add package IronPdf --version 2024.4.2

Añade el siguiente código.

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

Código Explicación

En primer lugar, creamos el contenido del PDF mediante un objeto de cadena de contenido. El contenido se crea como una cadena HTML.
Crea una nueva lista enlazada de cadenas con un nuevo LinkedList<string>().
Añade elementos a la lista enlazada y también a la cadena de contenido del PDF.
Imprime los elementos de la lista enlazada.
Inserta un elemento en una posición específica usando el método AddAfter y muestra la lista resultante.
Elimina un elemento de la lista enlazada utilizando el método Remove e imprime la lista resultante.
Finalmente, guarde la cadena de contenido HTML generada en un documento PDF utilizando los métodos ChromePdfRenderer, RenderHtmlAsPdf y SaveAs.

Salida

Lista Enlazada de C# (Cómo Funciona para Desarrolladores): Figura 6 - IronPDF con `LinkedList` Salida

La salida tiene una marca de agua que se puede eliminar utilizando una licencia válida de la página de licencias de IronPDF.

Licencia IronPDF

La biblioteca IronPDF requiere una licencia para funcionar, y se puede obtener en la página de licencias del producto.

Pegue la clave en el archivo appSettings.json que aparece a continuación.

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

Conclusión

C# LinkedList proporciona una estructura de datos versátil para gestionar colecciones de elementos, ofreciendo inserciones y eliminaciones eficientes al tiempo que permite un redimensionamiento dinámico similar a la función hash predeterminada. Las listas enlazadas se utilizan habitualmente en diversas aplicaciones y algoritmos, como la implementación de pilas, colas, tablas de símbolos y sistemas de gestión de memoria. Comprender las características y operaciones de las listas enlazadas es esencial para construir soluciones de software eficientes y escalables.

En resumen, aunque las listas enlazadas destacan en determinados escenarios, como las estructuras de datos dinámicas y las inserciones/eliminaciones frecuentes, puede que no sean la mejor opción para aplicaciones que requieran accesos aleatorios frecuentes o que se enfrenten a entornos con limitaciones de memoria. Un examen minucioso de los requisitos y características específicos de los datos puede orientar la selección de la estructura de datos más adecuada para la tarea en cuestión.

La biblioteca IronPDF de Iron Software permite a los desarrolladores crear y manipular documentos PDF sin esfuerzo, lo que permite desarrollar aplicaciones modernas con conocimientos avanzados.

Chipego Kalinda

Chatea con el equipo de ingeniería ahora

Ingeniero de software

Chipego tiene una habilidad natural para escuchar que le ayuda a comprender los problemas de los clientes y a ofrecer soluciones inteligentes. Se unió al equipo de Iron Software en 2023, después de estudiar una licenciatura en Tecnología de la Información. IronPDF e IronOCR son los dos productos en los que Chipego se ha centrado, pero su conocimiento de todos los productos crece día a día, a medida que encuentra nuevas formas de ayudar a los clientes. Disfruta de lo colaborativa que es la vida en Iron Software, con miembros del equipo de toda la empresa que aportan su variada experiencia para contribuir a soluciones eficaces e innovadoras. Cuando Chipego está lejos de su escritorio, a menudo se le puede encontrar disfrutando de un buen libro o jugando al fútbol.

< ANTERIOR
C# Reverse String (Cómo funciona para desarrolladores)

SIGUIENTE >
C# iList (Cómo funciona para desarrolladores)