Programa de

Ing. De Sistemas

Estructura
de Datos
Sesión 9

Tema:
Taller de
Programación
Resultado de aprendizaje Evidencia de aprendizaje

Aplica estructuras dinámicas lineales en la Informe de laboratorio: taller de programación.

construcción de soluciones informáticas de una
organización.
Contenido
Taller de Programación

• Listas Doblemente Enlazadas

• Listas Circulares
Revisa el
siguiente
video:
Después de haber visualizado el video en la slide
anterior, reflexionamos y respondemos las
siguientes interrogantes:

01 ¿Cuál es la analogía empleada en el video?

02 ¿Cuáles son los criterios para insertar un auto?

03 ¿Cómo sabemos cuantos autos hay?

 Tema
Taller de
Programación
Estructura de Datos – Sesión 9

Lista doblemente enlazada

Cada nodo contiene dos enlaces, uno a su nodo predecesor y el otro a su nodo sucesor.
La lista es eficiente tanto como en recorrido directo (“adelante”) como en recorrido
inverso (“atrás”).
Estructura de Datos – Sesión 9

Nodo
public class Nodo {
int dato;
Nodo sig;
Nodo ant;
public Nodo(int num)
public class Nodo { { dato=num;
sig=ant=null;
private int data; // almacena el dato }
private Nodo sig; //”enlace” al próximo nodo }

private Nodo ant; // ”enlace” al anterior nodo

}
Estructura de Datos – Sesión 9

Operaciones de una lista doblemente enlazada

• Añadir o insertar elementos.

• Buscar elementos.
• Borrar elementos.
• Moverse a través de la lista, siguiente y anterior.

sig

ant

Inicio fin
Estructura de Datos – Sesión 9

Insertar nuevo nodo

Insertar nodo en la primera posición

Nuevo
nodo

InsertaNodo( nodo)
1-. Nodosiguiente // debe apuntar a Lista.
2-. Nodoanterior y Listaanterior // debe apuntar a null
3-. Listaanterior //debe apuntar a nodo.
1
null
2 Dato Dato Dato …
3
Estructura de Datos – Sesión 9

public class Nodo {

Insertar nuevo nodo int dato;
Nuevo
Nodo sig;
nodo Nodo ant;
public Nodo(int
num)
{ dato=num;
sig=ant=null;
}
Nodo InsertaInicio(Nodo inicio, int num) }
{ Nodo nuevo=new Nodo(num); // se llama al constructor
//Realizando los enlaces correspondientes
nuevo.sig=inicio;
if(inicio==null) // solo para la primera vez
{ fin=nuevo;
fin.sig=null;
}
if(inicio!=null)
inicio.ant=nuevo;
inicio=nuevo;
return inicio;
}
Estructura de Datos – Sesión 9

Recorrido en una lista doble

HACIA ADELANTE HACIA ATRAS

int Suma(Nodo inicio) int Suma(Nodo fin)

{ Nodo aux=inicio; { Nodo aux=fin;
int suma=0; int suma=0;
//Recorriendo la lista //Recorriendo la lista
while(aux!=null) while(aux!=null)
{ //Sumando los datos { //Sumando los datos
suma=suma+aux.dato; suma=suma+aux.dato;
//Avanzando al siguiente nodo //Retrocediendo al nodo anterior
aux=aux.sig; aux=aux.ant;
} }
return suma; return suma;
} }
Estructura de Datos – Sesión 9

Eliminar

Caso 1 Eliminar el único nodo

En este caso, ese nodo será el apuntado por
Lista.

1.- Eliminamos el nodo.

2.- Hacemos que Lista apunte a NULL.
Estructura de Datos – Sesión 9

Eliminar

eliminaPrimer( nodo)
1.- Si nodo apunta a Lista // hacemos que Lista apunte
Lista=siguiente.
2.- Hacemos que nodo=siguiente=anterior// apunte a NULL
3.- Borramos el nodo apuntado por nodo.

Caso 2
Caso 2.1Eliminar el primer nodo
Estructura de Datos – Sesión 9

Eliminar

Caso 2.2 Eliminar un nodo intermedio

eliminaMedio(nodo)
1-. Si nodo apunta a Lista
Lista=siguiente
2-. nodo= siguiente
3-. Nodo = anterior
4-. Borramos el nodo apuntado por nodo
Estructura de Datos – Sesión 9

Eliminar
Caso 3 Eliminar el último nodo

eliminaUltimo(nodo)
1-. Si nodo apunta a Lista
Lista=anterior.
2- nodo=anterior=siguiente apunte a NULL
3-. Borramos el nodo apuntado por nodo.
 void Eliminar(Nodo inicio, int elem)
Estructura de Datos – Sesión 9

{ Nodo actual;
Eliminar boolean encontrado=false;
actual=inicio;
while((actual!=null)&& (!encontrado)) //bucle de Búsqueda
{ encontrado=(actual.dato==elem); // se actualiza elvalor de
encontrado
if(!encontrado) // severifica para pasar al siguiente nodo
actual=actual.sig;
}
//Realizando los enlaces
if (actual != null) // se verifica si se encontro el elemento buscado
{ if (actual == ini)
{ ini = actual.sig; // borrar el primero
if(actual.sig!=null)
actual.sig.ant=null;
}
else if (actual.sig!=null) // No es el ultimo
{ actual.ant.sig=actual.sig;
actual.sig.ant=actual.ant;
}
else
{ actual.ant.sig=null; // el ultimo
fin=actual.ant; // moviendo el final
}
actual=null;
}
}
Estructura de Datos – Sesión 9

Buscar
public class Nodo{
// atributos
public String codigo;
// puntero al siguiente nodo
BUSCAR UN NODO CON public Nodo sig ;
public Nodo ant;
ALGUNA CARACTERÍSTICA // el constructor de nodos
Nodo (String cod)
{ codigo=cod;
ant = sig = null;
}
}

Nodo Buscar(Nodo inicio,String cod)

{ //Generamos un puntero y lo colocamos al inicio de la lista
Nodo pos=inicio;
//Recorriendo la lista para encontrar la información
while(pos!=null && !cod.equalsIgnoreCase(pos.codigo))
pos=pos.sig;
//Retorno de la posición del dato
return pos;
}
Estructura de Datos – Sesión 9

Ejemplo

Construya una aplicación que

utilice listas doblemente
enlazadas y que permita realizar
el registro de empleados donde
se podrá guardar, mostrar,
consultar, actualizar y eliminar el
registro de empleado. Para todas
estas operaciones considere el
ingreso del código del empleado.
Estructura de Datos – Sesión 9

Ejemplo
DECLARACIÓN DEL CLASE NODO
Estructura de Datos – Sesión 9

Ejemplo
Estructura de Datos – Sesión 9

Ejemplo
BOTÓN GUARDAR
 Estructura de Datos – Sesión 9

Ejemplo

BOTÓN
CONSULTAR
Estructura de Datos – Sesión 9

Ejemplo

BOTÓN ACTUALIZAR
 Estructura de Datos – Sesión 9

Ejemplo

BOTÓN
ELIMINAR
Estructura de Datos – Sesión 8

Listas Circulares: Definición

El ultimo elemento (cola) se enlaza al primer elemento (cabeza), de tal

modo que la lista puede se recorrida de modo circular (“anillo”)
Estructura de Datos – Sesión 8

Listas Circulares: Definición

Una lista circular es una lista lineal en la que el último nodo a punta al
primero.

inicio
fin
Estructura de Datos – Sesión 8

Operaciones de una lista circular

Las operaciones que se pueden realizar sobre las listas circulares :

• Añadir o insertar elementos.
• Buscar o localizar elementos.
• Borrar elementos.
• Moverse a través de la lista
Estructura de Datos – Sesión 8

Declaración de una lista circular

Los elementos de lista pueden ser de cualquier tipo, solo varia a las demás
listas en el constructor, la referencia enlace en vez de inicializarla a null
se inicializa para que apunte al mismo nodo, así forma una lista circular
de un solo nodo.
public class Nodo {
int dato;
Nodo enlace;
public Nodo(int
num)
{ dato=num;
enlace=this;
}
}
Estructura de Datos – Sesión 8

Insertar un elemento

Insertar elemento en la lista vacía

• lista apunta a nodo.
• Lista->siguiente apunte a nodo.

Insertar elemento en una lista no vacía

1. Hacemos que nodo = siguiente apunte a lista = siguiente.
2. Después que lista = siguiente apunte a nodo.
Estructura de Datos – Sesión 8

Insertar un elemento

public class Nodo {

int dato;
Nodo enlace;
public Nodo(int num)
{ dato=num;
enlace=this;
}
Nodo InsertaFinal(Nodo lc, int num) }
{ //Llamada al constructor
Nodo nuevo=new Nodo(num);
//Realizando los enlaces correspondientes

if(lc!=null)
{ nuevo.enlace=lc.enlace;
lc.enlace=nuevo;
}
lc=nuevo;
return lc;
}
Estructura de Datos – Sesión 8

Recorrido de una Lista Circular

public class Nodo {
int dato;
Nodo enlace;
int Resumen() public Nodo(int num)
{ int suma=0; { dato=num;
Nodo p; enlace=this;
}
if(lc!=null) // verificando si la lista es vacia }
{ p=lc.enlace;
do
{
suma=suma+p.dato; // sumando los datos
p=p.enlace; // pasando a la siguiente
posicion

}while(p!=lc.enlace);

return suma;
}
Estructura de Datos – Sesión 8

Eliminar un elemento de la lista

Eliminar el único nodo de la lista.

1. lista = siguiente mientras lista = siguiente sea distinto de nodo.
2. Hacemos que lista = siguiente apunte a nodo = siguiente.
3. Eliminamos el nodo.

Eliminar un nodo en una lista circular con más de un elemento

4. Borramos el nodo apuntado por lista.
5. Hacemos que lista valga NULL.
Estructura de Datos – Sesión 8

Eliminar un elemento de la lista

Caso general
1. Copiamos el contenido del nodo = siguiente sobre el contenido de nodo.
2. Hacemos que nodo = siguiente apunte a nodo = siguiente = siguiente.
3. Eliminamos nodo = siguiente.
4. Si lista es el nodo = siguiente, hacemos lista = nodo.
Estructura de Datos – Sesión 8

Eliminar un elemento de la lista

public class Nodo {
void Eliminar(Nodo lc, int elem) int dato;
{ Nodo actual; Nodo enlace;
boolean encontrado=false; public Nodo(int num)
actual=lc; { dato=num;
while((actual.enlace!=lc)&& (!encontrado)) //bucle de Busqueda enlace=this;
{ encontrado=actual.enlace.dato==elem; }
if(!encontrado) actual=actual.enlace; }
}
//Verificando el dato nuevamente
encontrado=actual.enlace.dato==elem;
//Enlace de nodo anterior con el siguiente
if (encontrado)
{ Nodo p;
p=actual.enlace; // Nodo a Eliminar
if(lc==lc.enlace) lc=null; //Lista con un solo nodo
else
{ if(p==lc) lc=actual; // Se borra el elemento referenciado por lc el nuevo acceso a la lista es
el anterior
actual.enlace=p.enlace;
}
}
}
Estructura de Datos – Sesión 8

Buscar un nodo con alguna característica

public class Nodo {
int dato;
Nodo enlace;
public Nodo(int num)
{ dato=num;
Nodo Buscar(Nodo lc,int elem) enlace=this;
{ Nodo actual; }
}
boolean encontrado=false;
actual=lc;
//bucle de Busqueda
while((actual.enlace!=lc)&& (!encontrado))
{ encontrado=actual.enlace.dato==elem;
if(!encontrado)
actual=actual.enlace;
}
// se retorna la referencia
return actual.enlace;
}
Estructura de Datos – Sesión 8

Ejemplo

Construya una aplicación que

utilice listas circular y que permita
realizar el registro de empleados
donde se podrá guardar, mostrar,
consultar, actualizar y eliminar el
registro de empleado. Para todas
estas operaciones considere el
ingreso del código del empleado.
Estructura de Datos – Sesión 8

Ejemplo

DECLARACIÓN DEL CLASE NODO

Estructura de Datos – Sesión 8

Ejemplo
Estructura de Datos – Sesión 8

Ejemplo
BOTÓN GUARDAR
 Estructura de Datos – Sesión 8

Ejemplo

BOTÓN
CONSULTAR
Estructura de Datos – Sesión 8

Ejemplo

BOTÓN ACTUALIZAR
 Estructura de Datos – Sesión 8

BOTÓN
ELIMINAR
Ejemplo
Estructura de Datos – Sesión 8

Ejemplo

MÉTODO RESUMEN
Autoevaluación
Sesión 9
 Una lista circular es:

Una lista lineal en la que el último nodo a punta al primero

Pregunta 1

Una lista vectorial en la que el último nodo a punta al primero

Una lista lineal en la que el penúltimo nodo a punta al primero

Todas so falsas
 Una lista circular es:

Una lista lineal en la que el último nodo a punta al primero

Pregunta 1

Una lista vectorial en la que el último nodo a punta al primero

Una lista lineal en la que el penúltimo nodo a punta al primero

Todas so falsas
 Son operaciones de listas circulares

Añadir, Buscar, Rotar, Moverse

Pregunta 2

Reusar, Buscar, Eliminar, Moverse

Añadir, Buscar, Eliminar, Reutilizar

Añadir, Buscar, Eliminar, Moverse

 Son operaciones de listas circulares

Añadir, Buscar, Rotar, Moverse

Pregunta 2

Reusar, Buscar, Eliminar, Moverse

Añadir, Buscar, Eliminar, Reutilizar

Añadir, Buscar, Eliminar, Moverse

 Como declaramos un nodo:

public class Nodo {

private int data;
private Nodo sig;
private Nodo ant;
Pregunta 3

}
public class Nodo {
private Nodo ant;
private int data;
private Nodo sig;
}
public class Nodo {
private Nodo sig;
private Nodo ant;
private int data;
}
Todas son correctas
 Como declaramos un nodo:

public class Nodo {

private int data;
private Nodo sig;
private Nodo ant;
Pregunta 3

}
public class Nodo {
private Nodo ant;
private int data;
private Nodo sig;
}
public class Nodo {
private Nodo sig;
private Nodo ant;
private int data;
}

Todas son correctas

 Una lista doble se puede recorrer:

Siempre haca adelante, pero nunca hacia atrás

Pregunta 4

Hacia adelante o hacia atrás

Únicamente hacia atrás pero no hacia adelante

Todas son falsas

 Una lista doble se puede recorrer:

Siempre haca adelante, pero nunca hacia atrás

Pregunta 4

Hacia adelante o hacia atrás

Únicamente hacia atrás pero no hacia adelante

Todas son falsas

Autoevaluación
¡Vamos por más logros!

¡Felicitaciones!
Ha concluido la autoevaluación
 Una lista enlazada (Linked List) – es una secuencia de nodos. Junto con el
arreglo (array), la lista enlazada es considerada una de las estructuras de
datos fundamentales y puede ser utilizada para implementar otras
estructuras más complejas. El acceso a los nodos en una lista enlazada es
normalmente secuencial, excepto el acceso al primer nodo y posiblemente,
Conclusiones

el acceso al último nodo.

Las listas enlazadas pueden clasificarse como:

a. Lista Simplemente Enlazada (Singly Linked List) – es aquella en la

cual cada nodo contiene un enlace al próximo nodo. El último nodo
contiene un enlace a null.
b. Lista Doblemente Enlazada (Doubly Linked List) – es aquella en la
cual cada nodo contiene un enlace al próximo nodo y un enlace al
nodo anterior. El último nodo contiene un enlace a null como su
sucesor. El primer nodo contiene un enlace a null como su antecesor.
c. Lista Enlazada Circular (Circular Linked List) – es aquella en la cual
el último nodo está enlazado con el primero.
Aplicando lo
aprendido:
A partir de los conceptos estudiados en la presente sesión
desarrollamos la Guía de Laboratorio 08 que encontraremos en la
plataforma Blackboard, luego sube tu solución en la sesión
correspondiente a la evaluación.
 BLASCO, Francisco. Programación Orientada a Objetos en Java. [en
línea]. Madrid: RA-MA Editorial. 2019. ISBN: 9788499648651.
Disponible en:
Referencias

https://www.alphaeditorialcloud.com/reader/programacion-orientada-
a-objetos-en-jav a-1591713437?preview=true
.

CAMPESATO, Osward. Data Structures in Java. [en línea]. 1st. Ed.

Bloomfield: Mercury Learning & Information. 2023. ISBN: 1-68392-953-
5. Disponible en:
https://app.knovel.com/kn/resources/kpDSJ00003/toc?cid=toc

CEBALLOS, Francisco Javier. Programación orientada a objetos con C++.

[en línea]. 5ta Ed. Madrid: RA-MA Editorial. ISBN: 9788499647845.
Disponible en:
https://www.digitaliapublishing.com/viewepub/?id=110114