Capítulo 8: Estructuras de Datos Utilizadas en Algoritmos
8.2 Listas Enlazadas
Las listas enlazadas son un tipo de estructura de datos fascinante y poderoso que se puede utilizar para resolver una variedad de problemas. Organizan elementos de manera secuencial, con cada elemento teniendo un puntero al siguiente en la lista. Este enfoque simple pero elegante permite la inserción y eliminación eficientes de elementos, lo que las hace ideales para situaciones donde se requieren estructuras de datos dinámicas.
Además de su eficiencia, las listas enlazadas también son increíblemente flexibles. Pueden ser simples, donde cada elemento apunta al siguiente, o dobles, donde cada elemento apunta tanto al siguiente como al anterior en la lista. Esta flexibilidad permite una amplia gama de aplicaciones, desde implementar pilas y colas hasta crear estructuras de datos complejas como árboles y grafos.
En general, las listas enlazadas son un concepto fundamental en la ciencia de la computación y deberían ser parte del conjunto de herramientas de cada programador. Ya seas principiante o desarrollador experimentado, entender cómo funcionan las listas enlazadas y cómo usarlas puede ayudarte a resolver problemas de manera más eficiente y efectiva. Así que la próxima vez que te enfrentes a un desafío de estructura de datos, ¡recuerda considerar las listas enlazadas como una solución potencial!
En una lista enlazada, cada elemento está contenido en un nodo, que tiene dos elementos:
- Datos: Esto contiene el valor que se va a almacenar en el nodo.
- Siguiente: Esto contiene la referencia (o enlace) al siguiente nodo en la cadena.
El punto de partida de la lista enlazada se denomina cabeza. El último elemento, o cola, de la lista enlazada apunta a una referencia nula, lo que indica el final de la cadena.
Aquí tienes un diagrama simple para ilustrar el concepto:
[Head | ] --> [Data | ] --> [Data | ] --> [Data | Null]En Python, podemos definir una clase Node simple y una clase LinkedList de la siguiente manera:
class Node:
def __init__(self, data=None):
self.data = data
self.next = None
class LinkedList:
def __init__(self):
self.head = Node()La clase LinkedList mantiene una referencia al nodo principal (head). Inicialmente, este nodo no contiene ningún dato.
Ahora, agreguemos funcionalidad para añadir elementos al final (apéndice) y mostrar la lista:
class Node:
def __init__(self, data=None):
self.data = data
self.next = None
class LinkedList:
def __init__(self):
self.head = Node()
def append(self, data):
new_node = Node(data)
cur = self.head
while cur.next:
cur = cur.next
cur.next = new_node
def display(self):
elems = []
cur_node = self.head
while cur_node.next:
cur_node = cur_node.next
elems.append(cur_node.data)
print(elems)Así es como podemos crear una lista enlazada y añadir elementos a ella:
my_list = LinkedList()
my_list.append(1)
my_list.append(2)
my_list.append(3)
my_list.display() # Output: [1, 2, 3]¡Y ese es el concepto básico de una lista enlazada! En comparación con los arrays, las listas enlazadas son dinámicas y eficientes en algunas operaciones como la inserción y eliminación. Sin embargo, utilizan más memoria para almacenar datos debido al almacenamiento adicional necesario para los punteros y tienen tiempos de acceso más lentos para elementos individuales.
8.2.1 Otros Tipos de Listas Enlazadas
Listas Doblemente Enlazadas
En informática, una lista enlazada es una estructura de datos que consiste en una secuencia de nodos. Cada nodo contiene un elemento de datos y un enlace al siguiente nodo en la secuencia. Sin embargo, atravesar una lista enlazada desde el final hasta el principio es imposible sin información adicional.
¡Ahí es donde entra la lista doblemente enlazada! En una lista doblemente enlazada, cada nodo tiene un enlace tanto al siguiente nodo como al nodo anterior. Esto permite el recorrido en ambas direcciones, lo que puede ser útil en diversas aplicaciones. Por ejemplo, puede facilitar la manipulación de secuencias de datos en direcciones tanto hacia adelante como hacia atrás.
Sin embargo, una lista doblemente enlazada requiere más memoria que una lista enlazada simple, ya que necesita almacenar los enlaces adicionales. A pesar de esta desventaja, las listas doblemente enlazadas se utilizan ampliamente en diversas aplicaciones informáticas y son un concepto importante para aprender para los programadores aspirantes.
Ejemplo:
Cada nodo en una lista doblemente enlazada contiene un elemento y dos enlaces que apuntan al nodo anterior y al siguiente respectivamente.
class Node:
def __init__(self, data=None):
self.data = data
self.next = None
self.prev = None
class DoublyLinkedList:
def __init__(self):
self.head = NonePara agregar elementos a la lista, necesitarás un método que maneje adecuadamente los punteros prev y next.
- Listas Enlazadas Circulares
Una lista enlazada circular es un tipo de lista enlazada donde el último nodo apunta de regreso al nodo cabeza en lugar de a nulo. Esto forma una cadena circular, que puede ser útil en diversas aplicaciones. Por ejemplo, en el planificador de tareas de un sistema operativo, los datos suelen ser cíclicos, y una lista enlazada circular puede usarse para gestionar las tareas de manera circular.
Además, las listas enlazadas circulares pueden usarse en gráficos por computadora para crear formas con un límite circular, como arcos o círculos. También pueden usarse en varias estructuras de datos, como pilas y colas, para implementar algoritmos de manera más eficiente.
A pesar de su utilidad, las listas enlazadas circulares pueden ser más complejas que las listas enlazadas regulares, y requieren una gestión cuidadosa para evitar bucles infinitos y fugas de memoria. Sin embargo, con una implementación y uso adecuados, las listas enlazadas circulares pueden ser una herramienta poderosa en el arsenal de un programador.
Ejemplo:
En una lista enlazada circular, el next del último nodo apunta al primer nodo.
class Node:
def __init__(self, data):
self.data = data
self.next = None
class CircularLinkedList:
def __init__(self):
self.head = None
def append(self, data):
if not self.head:
self.head = Node(data)
self.head.next = self.head
else:
new_node = Node(data)
cur = self.head
while cur.next != self.head:
cur = cur.next
cur.next = new_node
new_node.next = self.headEn esta implementación, creamos un nuevo nodo. Si la lista está vacía (self.head es None), apuntamos self.head al nuevo nodo y hacemos que el next del nuevo nodo apunte a sí mismo. Si la lista no está vacía, recorremos hasta el final de la lista (donde cur.next es self.head) y ajustamos los punteros next del último nodo y el nuevo nodo para mantener la estructura circular.
8.2 Listas Enlazadas
Las listas enlazadas son un tipo de estructura de datos fascinante y poderoso que se puede utilizar para resolver una variedad de problemas. Organizan elementos de manera secuencial, con cada elemento teniendo un puntero al siguiente en la lista. Este enfoque simple pero elegante permite la inserción y eliminación eficientes de elementos, lo que las hace ideales para situaciones donde se requieren estructuras de datos dinámicas.
Además de su eficiencia, las listas enlazadas también son increíblemente flexibles. Pueden ser simples, donde cada elemento apunta al siguiente, o dobles, donde cada elemento apunta tanto al siguiente como al anterior en la lista. Esta flexibilidad permite una amplia gama de aplicaciones, desde implementar pilas y colas hasta crear estructuras de datos complejas como árboles y grafos.
En general, las listas enlazadas son un concepto fundamental en la ciencia de la computación y deberían ser parte del conjunto de herramientas de cada programador. Ya seas principiante o desarrollador experimentado, entender cómo funcionan las listas enlazadas y cómo usarlas puede ayudarte a resolver problemas de manera más eficiente y efectiva. Así que la próxima vez que te enfrentes a un desafío de estructura de datos, ¡recuerda considerar las listas enlazadas como una solución potencial!
En una lista enlazada, cada elemento está contenido en un nodo, que tiene dos elementos:
- Datos: Esto contiene el valor que se va a almacenar en el nodo.
- Siguiente: Esto contiene la referencia (o enlace) al siguiente nodo en la cadena.
El punto de partida de la lista enlazada se denomina cabeza. El último elemento, o cola, de la lista enlazada apunta a una referencia nula, lo que indica el final de la cadena.
Aquí tienes un diagrama simple para ilustrar el concepto:
[Head | ] --> [Data | ] --> [Data | ] --> [Data | Null]En Python, podemos definir una clase Node simple y una clase LinkedList de la siguiente manera:
class Node:
def __init__(self, data=None):
self.data = data
self.next = None
class LinkedList:
def __init__(self):
self.head = Node()La clase LinkedList mantiene una referencia al nodo principal (head). Inicialmente, este nodo no contiene ningún dato.
Ahora, agreguemos funcionalidad para añadir elementos al final (apéndice) y mostrar la lista:
class Node:
def __init__(self, data=None):
self.data = data
self.next = None
class LinkedList:
def __init__(self):
self.head = Node()
def append(self, data):
new_node = Node(data)
cur = self.head
while cur.next:
cur = cur.next
cur.next = new_node
def display(self):
elems = []
cur_node = self.head
while cur_node.next:
cur_node = cur_node.next
elems.append(cur_node.data)
print(elems)Así es como podemos crear una lista enlazada y añadir elementos a ella:
my_list = LinkedList()
my_list.append(1)
my_list.append(2)
my_list.append(3)
my_list.display() # Output: [1, 2, 3]¡Y ese es el concepto básico de una lista enlazada! En comparación con los arrays, las listas enlazadas son dinámicas y eficientes en algunas operaciones como la inserción y eliminación. Sin embargo, utilizan más memoria para almacenar datos debido al almacenamiento adicional necesario para los punteros y tienen tiempos de acceso más lentos para elementos individuales.
8.2.1 Otros Tipos de Listas Enlazadas
Listas Doblemente Enlazadas
En informática, una lista enlazada es una estructura de datos que consiste en una secuencia de nodos. Cada nodo contiene un elemento de datos y un enlace al siguiente nodo en la secuencia. Sin embargo, atravesar una lista enlazada desde el final hasta el principio es imposible sin información adicional.
¡Ahí es donde entra la lista doblemente enlazada! En una lista doblemente enlazada, cada nodo tiene un enlace tanto al siguiente nodo como al nodo anterior. Esto permite el recorrido en ambas direcciones, lo que puede ser útil en diversas aplicaciones. Por ejemplo, puede facilitar la manipulación de secuencias de datos en direcciones tanto hacia adelante como hacia atrás.
Sin embargo, una lista doblemente enlazada requiere más memoria que una lista enlazada simple, ya que necesita almacenar los enlaces adicionales. A pesar de esta desventaja, las listas doblemente enlazadas se utilizan ampliamente en diversas aplicaciones informáticas y son un concepto importante para aprender para los programadores aspirantes.
Ejemplo:
Cada nodo en una lista doblemente enlazada contiene un elemento y dos enlaces que apuntan al nodo anterior y al siguiente respectivamente.
class Node:
def __init__(self, data=None):
self.data = data
self.next = None
self.prev = None
class DoublyLinkedList:
def __init__(self):
self.head = NonePara agregar elementos a la lista, necesitarás un método que maneje adecuadamente los punteros prev y next.
- Listas Enlazadas Circulares
Una lista enlazada circular es un tipo de lista enlazada donde el último nodo apunta de regreso al nodo cabeza en lugar de a nulo. Esto forma una cadena circular, que puede ser útil en diversas aplicaciones. Por ejemplo, en el planificador de tareas de un sistema operativo, los datos suelen ser cíclicos, y una lista enlazada circular puede usarse para gestionar las tareas de manera circular.
Además, las listas enlazadas circulares pueden usarse en gráficos por computadora para crear formas con un límite circular, como arcos o círculos. También pueden usarse en varias estructuras de datos, como pilas y colas, para implementar algoritmos de manera más eficiente.
A pesar de su utilidad, las listas enlazadas circulares pueden ser más complejas que las listas enlazadas regulares, y requieren una gestión cuidadosa para evitar bucles infinitos y fugas de memoria. Sin embargo, con una implementación y uso adecuados, las listas enlazadas circulares pueden ser una herramienta poderosa en el arsenal de un programador.
Ejemplo:
En una lista enlazada circular, el next del último nodo apunta al primer nodo.
class Node:
def __init__(self, data):
self.data = data
self.next = None
class CircularLinkedList:
def __init__(self):
self.head = None
def append(self, data):
if not self.head:
self.head = Node(data)
self.head.next = self.head
else:
new_node = Node(data)
cur = self.head
while cur.next != self.head:
cur = cur.next
cur.next = new_node
new_node.next = self.headEn esta implementación, creamos un nuevo nodo. Si la lista está vacía (self.head es None), apuntamos self.head al nuevo nodo y hacemos que el next del nuevo nodo apunte a sí mismo. Si la lista no está vacía, recorremos hasta el final de la lista (donde cur.next es self.head) y ajustamos los punteros next del último nodo y el nuevo nodo para mantener la estructura circular.
8.2 Listas Enlazadas
Las listas enlazadas son un tipo de estructura de datos fascinante y poderoso que se puede utilizar para resolver una variedad de problemas. Organizan elementos de manera secuencial, con cada elemento teniendo un puntero al siguiente en la lista. Este enfoque simple pero elegante permite la inserción y eliminación eficientes de elementos, lo que las hace ideales para situaciones donde se requieren estructuras de datos dinámicas.
Además de su eficiencia, las listas enlazadas también son increíblemente flexibles. Pueden ser simples, donde cada elemento apunta al siguiente, o dobles, donde cada elemento apunta tanto al siguiente como al anterior en la lista. Esta flexibilidad permite una amplia gama de aplicaciones, desde implementar pilas y colas hasta crear estructuras de datos complejas como árboles y grafos.
En general, las listas enlazadas son un concepto fundamental en la ciencia de la computación y deberían ser parte del conjunto de herramientas de cada programador. Ya seas principiante o desarrollador experimentado, entender cómo funcionan las listas enlazadas y cómo usarlas puede ayudarte a resolver problemas de manera más eficiente y efectiva. Así que la próxima vez que te enfrentes a un desafío de estructura de datos, ¡recuerda considerar las listas enlazadas como una solución potencial!
En una lista enlazada, cada elemento está contenido en un nodo, que tiene dos elementos:
- Datos: Esto contiene el valor que se va a almacenar en el nodo.
- Siguiente: Esto contiene la referencia (o enlace) al siguiente nodo en la cadena.
El punto de partida de la lista enlazada se denomina cabeza. El último elemento, o cola, de la lista enlazada apunta a una referencia nula, lo que indica el final de la cadena.
Aquí tienes un diagrama simple para ilustrar el concepto:
[Head | ] --> [Data | ] --> [Data | ] --> [Data | Null]En Python, podemos definir una clase Node simple y una clase LinkedList de la siguiente manera:
class Node:
def __init__(self, data=None):
self.data = data
self.next = None
class LinkedList:
def __init__(self):
self.head = Node()La clase LinkedList mantiene una referencia al nodo principal (head). Inicialmente, este nodo no contiene ningún dato.
Ahora, agreguemos funcionalidad para añadir elementos al final (apéndice) y mostrar la lista:
class Node:
def __init__(self, data=None):
self.data = data
self.next = None
class LinkedList:
def __init__(self):
self.head = Node()
def append(self, data):
new_node = Node(data)
cur = self.head
while cur.next:
cur = cur.next
cur.next = new_node
def display(self):
elems = []
cur_node = self.head
while cur_node.next:
cur_node = cur_node.next
elems.append(cur_node.data)
print(elems)Así es como podemos crear una lista enlazada y añadir elementos a ella:
my_list = LinkedList()
my_list.append(1)
my_list.append(2)
my_list.append(3)
my_list.display() # Output: [1, 2, 3]¡Y ese es el concepto básico de una lista enlazada! En comparación con los arrays, las listas enlazadas son dinámicas y eficientes en algunas operaciones como la inserción y eliminación. Sin embargo, utilizan más memoria para almacenar datos debido al almacenamiento adicional necesario para los punteros y tienen tiempos de acceso más lentos para elementos individuales.
8.2.1 Otros Tipos de Listas Enlazadas
Listas Doblemente Enlazadas
En informática, una lista enlazada es una estructura de datos que consiste en una secuencia de nodos. Cada nodo contiene un elemento de datos y un enlace al siguiente nodo en la secuencia. Sin embargo, atravesar una lista enlazada desde el final hasta el principio es imposible sin información adicional.
¡Ahí es donde entra la lista doblemente enlazada! En una lista doblemente enlazada, cada nodo tiene un enlace tanto al siguiente nodo como al nodo anterior. Esto permite el recorrido en ambas direcciones, lo que puede ser útil en diversas aplicaciones. Por ejemplo, puede facilitar la manipulación de secuencias de datos en direcciones tanto hacia adelante como hacia atrás.
Sin embargo, una lista doblemente enlazada requiere más memoria que una lista enlazada simple, ya que necesita almacenar los enlaces adicionales. A pesar de esta desventaja, las listas doblemente enlazadas se utilizan ampliamente en diversas aplicaciones informáticas y son un concepto importante para aprender para los programadores aspirantes.
Ejemplo:
Cada nodo en una lista doblemente enlazada contiene un elemento y dos enlaces que apuntan al nodo anterior y al siguiente respectivamente.
class Node:
def __init__(self, data=None):
self.data = data
self.next = None
self.prev = None
class DoublyLinkedList:
def __init__(self):
self.head = NonePara agregar elementos a la lista, necesitarás un método que maneje adecuadamente los punteros prev y next.
- Listas Enlazadas Circulares
Una lista enlazada circular es un tipo de lista enlazada donde el último nodo apunta de regreso al nodo cabeza en lugar de a nulo. Esto forma una cadena circular, que puede ser útil en diversas aplicaciones. Por ejemplo, en el planificador de tareas de un sistema operativo, los datos suelen ser cíclicos, y una lista enlazada circular puede usarse para gestionar las tareas de manera circular.
Además, las listas enlazadas circulares pueden usarse en gráficos por computadora para crear formas con un límite circular, como arcos o círculos. También pueden usarse en varias estructuras de datos, como pilas y colas, para implementar algoritmos de manera más eficiente.
A pesar de su utilidad, las listas enlazadas circulares pueden ser más complejas que las listas enlazadas regulares, y requieren una gestión cuidadosa para evitar bucles infinitos y fugas de memoria. Sin embargo, con una implementación y uso adecuados, las listas enlazadas circulares pueden ser una herramienta poderosa en el arsenal de un programador.
Ejemplo:
En una lista enlazada circular, el next del último nodo apunta al primer nodo.
class Node:
def __init__(self, data):
self.data = data
self.next = None
class CircularLinkedList:
def __init__(self):
self.head = None
def append(self, data):
if not self.head:
self.head = Node(data)
self.head.next = self.head
else:
new_node = Node(data)
cur = self.head
while cur.next != self.head:
cur = cur.next
cur.next = new_node
new_node.next = self.headEn esta implementación, creamos un nuevo nodo. Si la lista está vacía (self.head es None), apuntamos self.head al nuevo nodo y hacemos que el next del nuevo nodo apunte a sí mismo. Si la lista no está vacía, recorremos hasta el final de la lista (donde cur.next es self.head) y ajustamos los punteros next del último nodo y el nuevo nodo para mantener la estructura circular.
8.2 Listas Enlazadas
Las listas enlazadas son un tipo de estructura de datos fascinante y poderoso que se puede utilizar para resolver una variedad de problemas. Organizan elementos de manera secuencial, con cada elemento teniendo un puntero al siguiente en la lista. Este enfoque simple pero elegante permite la inserción y eliminación eficientes de elementos, lo que las hace ideales para situaciones donde se requieren estructuras de datos dinámicas.
Además de su eficiencia, las listas enlazadas también son increíblemente flexibles. Pueden ser simples, donde cada elemento apunta al siguiente, o dobles, donde cada elemento apunta tanto al siguiente como al anterior en la lista. Esta flexibilidad permite una amplia gama de aplicaciones, desde implementar pilas y colas hasta crear estructuras de datos complejas como árboles y grafos.
En general, las listas enlazadas son un concepto fundamental en la ciencia de la computación y deberían ser parte del conjunto de herramientas de cada programador. Ya seas principiante o desarrollador experimentado, entender cómo funcionan las listas enlazadas y cómo usarlas puede ayudarte a resolver problemas de manera más eficiente y efectiva. Así que la próxima vez que te enfrentes a un desafío de estructura de datos, ¡recuerda considerar las listas enlazadas como una solución potencial!
En una lista enlazada, cada elemento está contenido en un nodo, que tiene dos elementos:
- Datos: Esto contiene el valor que se va a almacenar en el nodo.
- Siguiente: Esto contiene la referencia (o enlace) al siguiente nodo en la cadena.
El punto de partida de la lista enlazada se denomina cabeza. El último elemento, o cola, de la lista enlazada apunta a una referencia nula, lo que indica el final de la cadena.
Aquí tienes un diagrama simple para ilustrar el concepto:
[Head | ] --> [Data | ] --> [Data | ] --> [Data | Null]En Python, podemos definir una clase Node simple y una clase LinkedList de la siguiente manera:
class Node:
def __init__(self, data=None):
self.data = data
self.next = None
class LinkedList:
def __init__(self):
self.head = Node()La clase LinkedList mantiene una referencia al nodo principal (head). Inicialmente, este nodo no contiene ningún dato.
Ahora, agreguemos funcionalidad para añadir elementos al final (apéndice) y mostrar la lista:
class Node:
def __init__(self, data=None):
self.data = data
self.next = None
class LinkedList:
def __init__(self):
self.head = Node()
def append(self, data):
new_node = Node(data)
cur = self.head
while cur.next:
cur = cur.next
cur.next = new_node
def display(self):
elems = []
cur_node = self.head
while cur_node.next:
cur_node = cur_node.next
elems.append(cur_node.data)
print(elems)Así es como podemos crear una lista enlazada y añadir elementos a ella:
my_list = LinkedList()
my_list.append(1)
my_list.append(2)
my_list.append(3)
my_list.display() # Output: [1, 2, 3]¡Y ese es el concepto básico de una lista enlazada! En comparación con los arrays, las listas enlazadas son dinámicas y eficientes en algunas operaciones como la inserción y eliminación. Sin embargo, utilizan más memoria para almacenar datos debido al almacenamiento adicional necesario para los punteros y tienen tiempos de acceso más lentos para elementos individuales.
8.2.1 Otros Tipos de Listas Enlazadas
Listas Doblemente Enlazadas
En informática, una lista enlazada es una estructura de datos que consiste en una secuencia de nodos. Cada nodo contiene un elemento de datos y un enlace al siguiente nodo en la secuencia. Sin embargo, atravesar una lista enlazada desde el final hasta el principio es imposible sin información adicional.
¡Ahí es donde entra la lista doblemente enlazada! En una lista doblemente enlazada, cada nodo tiene un enlace tanto al siguiente nodo como al nodo anterior. Esto permite el recorrido en ambas direcciones, lo que puede ser útil en diversas aplicaciones. Por ejemplo, puede facilitar la manipulación de secuencias de datos en direcciones tanto hacia adelante como hacia atrás.
Sin embargo, una lista doblemente enlazada requiere más memoria que una lista enlazada simple, ya que necesita almacenar los enlaces adicionales. A pesar de esta desventaja, las listas doblemente enlazadas se utilizan ampliamente en diversas aplicaciones informáticas y son un concepto importante para aprender para los programadores aspirantes.
Ejemplo:
Cada nodo en una lista doblemente enlazada contiene un elemento y dos enlaces que apuntan al nodo anterior y al siguiente respectivamente.
class Node:
def __init__(self, data=None):
self.data = data
self.next = None
self.prev = None
class DoublyLinkedList:
def __init__(self):
self.head = NonePara agregar elementos a la lista, necesitarás un método que maneje adecuadamente los punteros prev y next.
- Listas Enlazadas Circulares
Una lista enlazada circular es un tipo de lista enlazada donde el último nodo apunta de regreso al nodo cabeza en lugar de a nulo. Esto forma una cadena circular, que puede ser útil en diversas aplicaciones. Por ejemplo, en el planificador de tareas de un sistema operativo, los datos suelen ser cíclicos, y una lista enlazada circular puede usarse para gestionar las tareas de manera circular.
Además, las listas enlazadas circulares pueden usarse en gráficos por computadora para crear formas con un límite circular, como arcos o círculos. También pueden usarse en varias estructuras de datos, como pilas y colas, para implementar algoritmos de manera más eficiente.
A pesar de su utilidad, las listas enlazadas circulares pueden ser más complejas que las listas enlazadas regulares, y requieren una gestión cuidadosa para evitar bucles infinitos y fugas de memoria. Sin embargo, con una implementación y uso adecuados, las listas enlazadas circulares pueden ser una herramienta poderosa en el arsenal de un programador.
Ejemplo:
En una lista enlazada circular, el next del último nodo apunta al primer nodo.
class Node:
def __init__(self, data):
self.data = data
self.next = None
class CircularLinkedList:
def __init__(self):
self.head = None
def append(self, data):
if not self.head:
self.head = Node(data)
self.head.next = self.head
else:
new_node = Node(data)
cur = self.head
while cur.next != self.head:
cur = cur.next
cur.next = new_node
new_node.next = self.headEn esta implementación, creamos un nuevo nodo. Si la lista está vacía (self.head es None), apuntamos self.head al nuevo nodo y hacemos que el next del nuevo nodo apunte a sí mismo. Si la lista no está vacía, recorremos hasta el final de la lista (donde cur.next es self.head) y ajustamos los punteros next del último nodo y el nuevo nodo para mantener la estructura circular.