UNIVERSIDAD NACIONAL DE CAJAMARCA

FACULTAD DE INGENIERÍA

Algoritmos y Estructura
de Datos II
LISTAS ENLAZADAS

2
Colecciones Vs Arreglos

• Si tuviéramos que elegir

trabajar un programa
java que tiene que
manipular varios datos,
qué elegiría Ud. hacerlo
con:
– Arreglos o
– Colecciones?
• Describa algunas
ventajas de su
propuesta

3
Recordemos que hemos aprendido

• ¿Qué tipos de datos

hemos estudiado hasta
el momento?
• ¿Podríamos decir
cuándo debo de utilizar
un tipo de colección
específica o se usa de
manera indistinta?

4
Qué pasaría si…

• … me piden que yo
implemente una
colección con
características
específicas, es decir una
serie de métodos
personalizados, ¿Cómo
lo implementaríamos?

5
Logro Esperado

• Al término de la sesión,
el estudiante diseña
programa Java que
permita realizar las
tareas básicas de una
colección, verificando el
buen funcionamiento
del mismo y aplicando
su propuesta para la
solución de un
problema real.

7
ESTRUCTURAS DINÁMICAS DE
DATOS

Tipos de datos abstractos

8
Estructuras dinámicas de datos

• Permiten crear estructuras de datos que se adapten a las

necesidades reales a las que suelen enfrentarse nuestros
programas.
• También permiten crear estructuras de datos muy flexibles, ya
sea en cuanto al orden, la estructura interna o las relaciones
entre los elementos que las componen.
• Las estructuras de datos están compuestas de otras pequeñas
estructuras a las que llamaremos nodos o elementos, que
agrupan los datos con los que trabajará nuestro programa y
además uno o más referencias autoreferenciales, es decir,
referencias a objetos del mismo tipo nodo.

9
Estructuras dinámicas de datos

• Una estructura básica de un nodo para crear listas de datos seria:

public class Nodo {
int dato;
Nodo sgt;
}
• El campo “sgt" puede referenciar a un objeto del
tipo nodo. De este modo, cada nodo puede
usarse como un ladrillo para construir listas de
datos, y cada uno mantendrá ciertas relaciones
con otros nodos.
• Para acceder a un nodo de la estructura sólo
necesitaremos una referencia a un nodo. 10
 Estructuras dinámicas de datos
• Para mostrar la estructura de las estructuras de datos
dinámicas nos ayudaremos de gráficos.
• Así por ejemplo El nodo anterior (código de la
estructura autoreferencial) se representará así:

Dato

11
Estructuras dinámicas de datos

• Las estructuras dinámicas son una implementación de TDAs o

TADs (Tipos Abstractos de Datos).
• Dependiendo del número de referencias y de las relaciones
entre nodos, podemos distinguir varios tipos de estructuras
dinámicas:
– Listas enlazadas: cada elemento sólo dispone de una referencia, que
referenciará al siguiente elemento de la lista o valdrá NULL si es el
último elemento.
– Pilas: son un tipo especial de lista, conocidas como listas LIFO (Last In,
First Out: el último en entrar es el primero en salir). Los elementos se
"amontonan" o apilan, de modo que sólo el elemento que está encima
de la pila puede ser leído, y sólo pueden añadirse elementos encima
de la pila.
– Colas: otro tipo de listas, conocidas como listas FIFO (First In, First Out:
El primero en entrar es el primero en salir). Los elementos se
almacenan en fila, pero sólo pueden añadirse por un extremo y leerse
por el otro.

12
 Listas enlazadas simples

Listas Enlazadas

13
 Listas Enlazadas

• La forma más simple de estructura dinámica es la lista enlazada. En esta

forma los nodos se organizan de modo que cada uno referencia al
siguiente, y el último no hace referencia a nada, es decir, la referencia del
nodo siguiente vale NULL.

Lista Dato Dato Dato Dato Null

• En las listas enlazadas existe un nodo especial: el primero.

• Normalmente diremos que nuestra lista es una referencia a ese primer
nodo y llamaremos a ese nodo la cabeza de la lista. Eso es porque
mediante esa única referencia podemos acceder a toda la lista.
• Cuando la referencia que usamos para acceder a la lista vale NULL,
diremos que la lista está vacía.

Lista Null
14
Lista Enlazada – Declaraciones de Tipos

• Declaraciones de tipos para manejar listas en java:

• Como ya se vió anteriormente usaremos la declaración de la
siguiente forma:
public class Nodo {
int dato;
Nodo sgt;

public Nodo(int dato) {

this.dato = dato;
this.sgt = null;
}
public Nodo(int dato, Nodo sgt) {
this.dato = dato;
this.sgt = sgt;
}
}

15
Lista Enlazada - Declaraciones de Tipos

• Para construir la lista se hace necesario crear la clase

ListaEnlazada, que estará formada de nodos.
• La referencia primero (también se puede llamar
cabeza) se ha inicializado en el constructor a un valor
nulo, es decir, a lista vacía.
public class ListaEnlazada {
Nodo primero;

public ListaEnlazada() {
primero=null;
}
}
16
Operaciones básicas con listas

• Entre las operaciones básicas a realizar tenemos:

– Añadir o insertar.
– Buscar o localizar.
– Borrar.
– Moverse a través de una lista, anterior, siguiente, primero.
• Cada una de estas operaciones tendrá varios casos
especiales, por ejemplo, no será lo mismo insertar un
nodo en una lista vacía, o al principio de una lista no
vacía, o la final, o en una posición intermedia.

17
 Insertar nodos en una lista enlazada
• Insertar un elemento en una lista vacía al inicio:
– Este es, evidentemente, el caso más sencillo.
– Partiremos de que ya tenemos una referencia a “primero”
que valdrá NULL (lista está vacía),
– Además el nodo a insertar y, por supuesto una referencia
que apunte a él,

primero Null primero = null;

//constructor de la lista

nuevo Dato Nodo nuevo = new Nodo();

18
 Insertar nodos en una lista enlazada
• Insertar un elemento en una lista vacía al inicio:
– El proceso es muy simple, bastará con que:
– nuevo.sgt apunte a primero (null).
– Primero referencia a nuevo.

primero Null nuevo.sgt=primero;

nuevo Dato primero=nuevo;

19
 Insertar nodos en una lista enlazada*

• 1 Insertar un elemento en la primera posición:

– El proceso es muy simple y bastante similar:
– nuevo.sgt apunte a primero.
– Primero referencia a nuevo.

nuevo.sgt = primero;
nuevo Dato
primero = nuevo;

primero Dato Dato Dato Null

20
 Mostrar los elementos de la lista
• Para mostrar los elementos de una lista necesitamos:
– Del tipo nodo creamos un temp que se iguala a primero
– Mientras temp sea diferente de null
• Mostramos temp.dato
• Actualizamos temp a temp.sgt

primero Dato Dato Dato Dato Null

temp
21
temp=primero; Muestra temp.dato; temp=temp.sgt;
Ejemplo de una Lista Enlazada simple

• Clase Nodo • Clase Lista Enlazada

public class Nodo { public class ListaEnlazada {
int dato; Nodo primero;
Nodo sgt; public ListaEnlazada() {
primero = null;
}
public Nodo(int dato, Nodo sgt) { public void insertaIni(int n) {
this.dato = dato; Nodo nuevo = new Nodo(n);
this.sgt = sgt; nuevo.sgt = primero;
} primero = nuevo;
}
public void imprimeLis() {
public Nodo(int dato) { Nodo temp = primero;
this(dato,null); while (temp!=null) {
} System.out.print(temp.dato + "\t");
temp = temp.sgt;
} }
}
}

22
Ejemplo de una Lista Enlazada simple

• Clase de Prueba
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
System.out.print("numero de elementos: ");
int n = sc.nextInt();

ListaEnlazada listita = new ListaEnlazada();

for (int i= 1; i<=n;i++){
System.out.print("dato " + i + ": ");
int temp = sc.nextInt();
listita.insertaIni(temp);
}
listita.imprimeLis();
} 23
 Funciones Tipo para el manejo de
listas enlazadas
Inserta un nodo al inicio Mostrar una lista
public void
insertaIni(int n) { public void
Nodo nuevo = new imprimeLis() {
Nodo(n); Nodo temp = primero;
nuevo.sgt = primero; while (temp!=null) {
primero = nuevo; System.out.print(temp.
} dato + "\t");
temp = temp.sgt;
}
}

24
 Insertar nodos en una lista enlazada

• Insertar un elemento en una lista vacía en la última

posición:
– El proceso es muy simple:
– nuevo.sgt apunte a null.
– primero apunte a nuevo.
primero null nuevo.sgt = null;

nuevo Dato primero = nuevo;

25
 Insertar nodos en una lista enlazada*
• Insertar un elemento en la última posición:
– Partimos de una lista no vacía:
– Necesitamos una referencia que señale al último elemento de la lista
(anterior).
– La manera de conseguirlo es empezar por el primero y avanzar hasta que el
nodo tenga como siguiente el valor null.
– Hacer que nuevo.sgt sea null. nuevo.sgt = null
– Hacer que anterior.sgt sea nuevo.
anterior.sgt = nuevo
anterior = primero
while(anterior.sgt != null)
anterior
anterior=anterior.sgt nuevo Dato

primero Dato Dato Dato Null

26
 Insertar nodos en una lista enlazada*
• Insertar nodo a continuación de un nodo cualquiera:
– Podemos considerar el caso anterior como un caso particular de este. Ahora
el nodo "anterior" será aquel a continuación del cual insertaremos el nuevo
nodo :
– Suponemos que ya disponemos del nuevo nodo a insertar, apuntado por
nuevo, y un puntero al nodo a continuación del que lo insertaremos
(anterior). El proceso a seguir será.
– Hacer que nuevo.sgt señale a anterior.sgt
anterior = primero;
– Hacer que anterior.sgt señale a nuevo. for(int i=1;anterior!= null;i++){
if(i == pos-1){
nuevo.sgt = anterior.sgt //inserta
}
anterior = anterior.sgt;
anterior.sgt = nuevo }
nuevo Dato
anterior

primero Dato Dato Dato Null

27
 Eliminar elementos de una lista*
• Eliminar el primer nodo de la lista:
– Asumimos que tenemos una lista (primero) con uno o más nodos.
– primero apunta al siguiente nodo (segundo nodo)
– Java libera la memoria asignada al elemento a eliminar

primero = primero.sgt

primero Dato Dato Dato Null

28
 Eliminar elementos de una lista *
• Elimina un nodo cualquiera de una lista.
– Partimos de una lista no vacía con al menos dos elementos:
– Necesitamos además una referencia que señale al nodo anterior al que
queremos eliminar (anterior). Hacemos que p apunte al nodo que queremos
borrar
– Luego indicamos que anterior.sgt apunte hacia p.sgt
– Java libera la memoria del elemento eliminado.
anterior = primero;
for(int i=1;anterior!=null;i++){
if(i == pos-1){
//elimina
anterior }
anterior = anterior.sgt;
}

primero Dato Dato Dato Dato Null

p = anterior.sgt
p 29
anterior.sgt = p.sgt
 Eliminar elementos de una lista *
• Eliminar el último elemento de la lista (alternativa 1):
– En nuestro ejemplo partimos de una lista no vacía:
– Necesitamos un puntero que señale al penúltimo elemento de la lista
(anterior) y que p apunte al elemento a eliminar (último).
– Luego indicamos que anterior.sgt apunte hacia p.sgt
– El garbage collector libera la memoria del elemento a eliminar.
p = primero

while(p.sgt != null){
anterior = p
p = p.sgt
}
anterior p anterior.sgt = p.sgt

primero Dato Dato Dato Null

30
 Eliminar elementos de una lista *
• Eliminar el último elemento de la lista (alternativa 2):
– En nuestro ejemplo partimos de una lista no vacía:
– Necesitamos un puntero que señale al penúltimo elemento de la lista
(anterior).
– Luego indicamos que anterior.sgt apunte hacia null
– El garbage collector libera la memoria del elemento a eliminar.

anterior = primero

while(anterior.sgt.sgt != null){
anterior = anterior.sgt
}
anterior anterior.sgt = null

primero Dato Dato Dato Null

31
Eliminar elementos de una lista

Elimina toda una lista

• Hacemos que primero apunte a null.

primero == null

32
RECORDANDO LO APRENDIDO

33
Reflexionemos sobre lo aprendido

• ¿Cuál es la estructura
básica de una lista
enlazada?
• ¿Qué parte del código
modificaría para que la
lista enlazada estudiada
permita registrar los
datos de una persona?
• ¿Qué dificultades o
desventajas encuentra en
esta lista enlazada?
¿Podríamos mejorarla?

34
 EJERCICIOS DE APLICACIÓN

Poniendo en práctica lo aprendido

35
Ejercicios de aplicación

Agregar un método a la lista

enlazada que:
• Determine la cantidad de
elementos que tiene la lista.
• Ordene los elementos de la
lista
• Inserte los elementos en la
lista, de tal manera que
estos se inserten
ordenados.
• Cree un menú de opciones
que permita gestionar la
lista de canciones de mi
reproductor musical

36