1/26/2021

Listas circulares. Concepto (I).

 El último elemento de la lista tiene un enlace al primer nodo
de ella.
 En principio, el puntero de referencia inicio podría apuntar a
cualquier elemento de la lista. Importante no “perderlo”

1 3
Lista

inicio
nombre
?
Listas. 5
NodoLista 7
Listas circulares (anillos)

 Desde un punto de vista lógico, el puntero inicio ha

de permitir determinar la finalización del recorrido
iterativo o recursivo

Listas circulares. Concepto (II). Listas circulares. Inserción: casuística.

 Puntero inicio: ¿apunta al primer o al último
elemento?  Hay que tener en cuenta tres casos distintos:
 Si apunta al primer elemento:  La lista está vacía: Insertar el nodo y enlazar consigo
 Acceso inmediato al primer elemento, pero hay recorrer mismo
la lista completa para llegar al último
 Se inserta al final: Insertar el nodo y cambiar el
 Si apunta al último elemento: puntero inicio.
 Acceso inmediato al último elemento y al primero
mediante lista.inicio.sig  Insertar en cualquier otra posición.
NodoLista
Lista
 Para desarrollar los algortimos de inserción y
inicio

nombre

eliminación, consideraremos que la referencia

1 contenida en la lista apunta al último elemento de
3 5 7
la lista (y en vez de inicio se denominará ultimo)

Listas circulares. Inserción: código (I). Listas circulares. Inserción: código (II).
public void insertarCircular (int dato) {
NodoLista aux, actual, anterior; if (actual.clave != dato) {
if (ultimo == null) {
aux = new NodoLista (dato);
aux = new NodoLista (dato);
ultimo = aux;
if ((actual != ultimo) || (actual.clave > dato)) {
aux.sig = ultimo; aux.sig = actual;
} anterior.sig = aux;
else { }
anterior = ultimo; else if (actual.clave < dato) {
actual = ultimo.sig; aux.sig = actual.sig;
while ((actual.clave < dato) && (actual != ultimo)) { actual.sig = aux;
anterior = actual;
ultimo= aux;
actual = actual.sig;
}
}
}
else System.out.println ("Error, el elemento ya existe");
}
}

1
 1/26/2021

Listas circulares. Eliminación: código (I).

Listas circulares. Eliminación: casuística.
static void eliminar (int x){
 Se presentan tres situaciones: NodoLista anterior, actual;
if (ultimo != null) {
 La lista sólo tiene un nodo y se desea borrar anterior = ultimo;
 Se va a borrar el nodo final: hay que actualizar el nodo actual = anterior.sig;
while (actual != ultimo && actual.clave < x) {
inicio. anterior = actual;
actual = actual.sig;
 Se va a borrar cualquier otro elemento }
if (actual.clave == x) {
anterior.sig = actual.sig;
if (ultimo == actual)
if (ultimo != anterior)
ultimo = anterior;
else ultimo = null;
}
else System.out.println ("No existe el nodo de clave “ + x);
}
else System.out.println ("La lista está vacía ");
}

Listas circulares. Aplicaciones. Listas circulares. Aplicaciones.

 Pueden ser lista circular enlazada simple o lista circular enlazada
doblemente.  Un búfer de fluctuación es un tipo de búfer que toma paquetes numerados de
 Un juego de mesa multijugador, con una lista circular enlazada. una red y los coloca en orden, para que (por ejemplo) un reproductor de video
o audio pueda reproducirlos en orden. Los paquetes que son demasiado
 Útiles para la implementación de la cola. A diferencia de la implementación,
lentos (lentos) se descartan.
básica, no se necesita mantener dos punteros para la parte delantera y trasera,
se puede representar en un búfer circular, sin necesidad de asignar y
mediante una lista circular vinculada. Podemos mantener un puntero al
desasignar constantemente la memoria, ya que las ranuras se pueden
último nodo insertado y el nodo del frente siempre se puede obtener como el
reutilizar una vez que se han escuchado.
último de los últimos.
 Podría implementarse con una lista vinculada, pero habría adiciones y
 Son útiles en aplicaciones, para recorrer repetidamente una lista. Por eliminaciones constantes a la lista, en vez de reemplazar las constantes (que son
ejemplo, cuando se ejecutan varias aplicaciones en un PC, es común que el más baratas).
sistema operativo ponga las aplicaciones en ejecución en una lista y luego las  La banda de maletas del aeropuerto
recorra, dándoles a cada una un poco de tiempo para ejecutarlas y luego las
 La banda de embotellado de una empresa
pone en espera mientras la CPU atiende a otra aplicación. Es conveniente que
el sistema operativo utilice una lista circular para que cuando llegue al final
de la lista pueda desplazarse al principio de la lista.
 Las listas circulares doblemente enlazadas se utilizan para la implementación
de estructuras de datos avanzadas como el heap de Fibonacci.

Listas doblemente enlazadas

 Concepto:
 La lista se puede recorrer en ambos sentidos.
 El elemento anterior al primero será el elemento nulo.
 El elemento siguiente al último será el elemento nulo.
 Modelo:
Lista NodoLista
null
2
inicio

nombre
1 5
null
Listas.
Listas doblemente enlazadas  Declaración de la clase:
class NodoLista {
public class Lista { int clave;
String nombre; NodoLista sig;
NodoLista inicio; NodoLista ant;

Lista () { NodoLista (int x) {

inicio = null; clave = x;
nombre = null; sig = null;
} ant = null;
} }
}

2
 1/26/2021

Listas doblemente enlazadas. Inserción Listas doblemente enlazadas. Eliminación

public void insertar (int clave) {
NodoLista anterior = inicio, actual = inicio, nuevo;
boolean encontrado = false; public void eliminar (int dato) {
while ((actual != null) && !encontrado) NodoLista anterior = inicio, actual = inicio;
if (actual.clave < clave) {
anterior = actual; boolean encontrado = false;
actual = actual.sig;
} while ((actual != null) && !encontrado)
else encontrado = true;
if (actual == null) { if (actual.clave < dato) {
nuevo = new NodoLista (clave); anterior = actual;
if (inicio == null) actual = actual.sig;
inicio = nuevo;
else { }
nuevo.ant = anterior; else encontrado = true;
anterior.sig = nuevo; if (actual == null)
}
} System.out.println("Error, el elemento no existe");
else if (actual.clave > clave) { else if (actual.clave > dato)
nuevo = new NodoListaDobleEnlace(clave);
nuevo.sig = actual; System.out.println("Error, el elemento no existe");
nuevo.ant = actual.ant; else if (inicio == actual) {
actual.ant = nuevo; inicio = lista.inicio.sig;
if (inicio != actual)
anterior.sig = nuevo; inicio.ant = null;
else inicio = nuevo; }
} else {
else System.out.println("error, la clave ya existe");
} anterior.sig = actual.sig;
actual.sig.ant = anterior;
}
}

Listas doblemente enlazadas. Aplicaciones

 Las aplicaciones de la lista doblemente enlazada

pueden ser:
 Una excelente manera de representar una baraja de cartas
en un juego.
 La memoria caché del navegador que le permite presionar
el botón ATRÁS (una lista vinculada de URLs)
 Aplicaciones que tienen una lista de Usados más
recientemente (MRU) (una lista vinculada de nombres de
archivos)
 Se puede implementar una pila, una tabla hash y un árbol
binario utilizando una lista doblemente vinculada.
 Deshacer funcionalidad en Photoshop o Word (una lista
vinculada de estados)