Listas circulares

Grupo 3
simples y dobles
•
Integrantes:

Moreno Vásquez, Paul Anderson

• Ortiz Villalobos, Xiomara Alessandra
• Agurto Herrera, Maricielo Abigail
• Bernabe Rios, Daniela Nicole
• Flores Ancajima, Gerson
 ¿Qué son las listas
circulares simples?
Es una estructura de datos en la que los elementos se
enlazan de tal manera que el último elemento esta
enlazado nuevamente con el primer elemento, lo que
hace que se forme un circulo o bucle. Estas carecen
de un inicio o final claramente definidos.
 ¿En que son útiles las listas
circulares simples?
Las listas circulares simples son especialmente útiles en situaciones en las que
se necesita acceder repetidamente a una colección de datos de manera continua
y cíclica, sin un inicio o final definidos. Su capacidad para formar bucles
facilita la implementación de tareas y operaciones que se repiten de forma
constante.
Ejemplos de listas
circulares simples
Código de lista
circular simple
 1

null
primero
primero nuevo

1 sig 2

ultimo null
 1 sig 2 sig
3

primero ultimo nuevo null

 1 sig
2 sig 3 sig
4
primero nuevo
null
sig
 ¿Qué son las listas
circulares
Aqui va q son las listas
dobles?
esas y tambien una
imagen de lista circular
doble
 ¿En que son útiles las listas
circulares dobles?
Las listas circulares dobles son útiles en situaciones en las que se requiere un
acceso continuo y bidireccional a elementos de datos en una colección, lo que
amplía su aplicabilidad en comparación con las listas circulares simples. Su
capacidad para moverse tanto hacia adelante como hacia atrás las hace
adecuadas para diversas aplicaciones, desde procesamiento de texto hasta
juegos y sistemas de control.
Ejemplos de listas
circulares dobles
Código de lista
circular dobles
Código de lista
• Nodo ultimo = inicio.anterior; Aquí, se crea una nueva variable `ultimo` que se inicializa con el nodo anterior al
nodo de inicio. En una lista circular doblemente enlazada, el nodo de inicio tiene un puntero al nodo

circular dobles
anterior, lo que permite un acceso eficiente al final de la lista.
• nuevoNodo.siguiente = inicio; El nuevo nodo que deseas insertar (referenciado como `nuevoNodo`) se conecta al
nodo de inicio como su siguiente. Esto significa que el nuevo nodo se convertirá en el último nodo de la lista
circular, y su puntero siguiente apuntará al nodo de inicio actual.
• inicio.anterior = nuevoNodo; El nodo de inicio actualiza su puntero anterior para apuntar al nuevo nodo. Esto
asegura que el nodo de inicio ahora tenga una referencia al nuevo nodo, completando así la conexión del
nuevo nodo con la lista.
• 4. `nuevoNodo.anterior = ultimo; El nuevo nodo también se conecta al nodo anterior al nodo de inicio, que
habías almacenado en la variable `ultimo`. Esto establece la referencia anterior del nuevo nodo al último
nodo de la lista circular.
• ultimo.siguiente = nuevoNodo; El nodo que originalmente era el último nodo (almacenado en la variable `ultimo`)
actualiza su puntero siguiente para apuntar al nuevo nodo. Esto cierra la conexión entre el antiguo último
nodo y el nuevo nodo, completando la inserción del nuevo nodo al final de la lista.
• public Nodo(int dato) { this.dato = dato; }`: Esta es la definición del constructor de la clase `Nodo`. Un nodo es
una estructura que contiene un dato y dos referencias: una al nodo siguiente y otra al nodo anterior en la
lista. En este caso, el constructor toma un argumento `dato` que se utiliza para inicializar el campo `dato`
del nodo. Esto es común en listas enlazadas, donde cada nodo almacena un valor (en este caso, `dato`) y
una referencia al siguiente nodo.
• `public ListaCircularDoble() { inicio = null; }`: Este es el constructor de la clase `ListaCircularDoble`. La lista
circular doblemente enlazada comienza con un nodo de inicio (a menudo llamado "cabeza") que apunta al
primer elemento de la lista. En este constructor, la variable `inicio` se inicializa como `null`, lo que indica
que la lista está vacía en el momento de su creación.
• `public void imprimir() { ... }`: Este es un método de la clase `ListaCircularDoble` que se utiliza para recorrer e
imprimir los elementos de la lista.
• Si `inicio` es `null`, significa que la lista está vacía, por lo que se muestra un mensaje indicando que la lista
está vacía.
• Si la lista no está vacía, se declara una variable `actual` que se inicializa con el valor de `inicio`. Esto se hace
para comenzar el recorrido desde el primer nodo de la lista.
• Luego, se utiliza un bucle `do-while` para recorrer la lista. Se muestra el valor del nodo actual
(`actual.dato`) y se avanza al siguiente nodo utilizando `actual.siguiente`. El bucle continúa hasta que
`actual` vuelva a ser igual a `inicio`, lo que indica que se ha completado un ciclo completo alrededor de la
lista circular.
• Finalmente, se imprime una nueva línea para formatear la salida.