SC-304 Estructuras

de Datos

Filminas de la semana 6
 • Presentación de la estructura Lista mediante
ejemplos de la cotidianeidad
• Acercamiento a la estructura Lista en Java
Agenda • Creación de las clases Persona y Nodo
• Revisión del atributo cabeza
• Casos a considerar en el método inserta
• Desarrollo de otros métodos en clase
(consulta, modifica, elimina)
Listas Enlazadas
Simples
Concepto de lista enlazada simple

Una lista enlazada simple es una estructuras de datos que

permite almacenar elementos de forma ordenada y en donde
se puede agregar y extraer nodos en cualquier lugar de la
estructura.

4
 • Las listas son una estructura que
tiene mayor funcionalidad que las
Pilas y las Colas.
• El mayor uso es con listas donde sus
cabeza elementos tienen algún orden entre
si. Pensemos en expedientes de
5 10 15 20 30 estudiantes dentro de un fichero
físico que se ordenan
alfabéticamente.
Características • En una lista se pueden insertar
elementos al inicio, al final y en el
de una lista medio de la estructura.
• Igualmente se puede consultar,
enlazada simple actualizar o eliminar cualquier
elemento de la lista, sin necesidad de
“sacar” los otros elementos.
5
 Vamos a crear las siguientes clases:

Definición • Persona
de clases • Nodo
• Lista
• Lec06 (prueba)

6
 Iniciemos la creación
de la lista

• Iniciamos Netbeans
• Hacemos un proyecto llamado Lec06
• Creamos las siguientes clases...

7
 Implementando la
clase Persona en
Java

• Vamos a crear una lista de Personas,

por lo que inicialmente requerimos de
una clase Persona.
• Esta clase sólo tendrá dos atributos:
• int id
• String nombre
• Los métodos generados
automáticamente
• Getter and Setter
• Constructores y
• toString

8
 Desarrollamos la
clase Persona y la
comparamos con el
modelo

9
 Implementando la
clase Nodo en Java

• Requerimos de una clase que

contenga una persona y la
referencia hacia otro elemento.
• Para ello hacemos la clase Nodo
• Atributos:
• Persona dato
• Nodo next
• Métodos (generados
automáticamente):
• Setter y getter
• Constructor (con dato)
• toString 10
 Desarrollamos la
clase Nodo y la
comparamos con el
modelo

11
 Implementando la
clase Lista en Java

• La clase lista es el la clase

principal de esta estructura. Por ahora se define así…
• Sólo tiene un atributo “cabeza”
que referencia al primer elemento
de la lista. cabeza

next next next next

dato: dato: dato: dato:

Persona Persona Persona Persona
 Existen lista ordenadas y no ordenadas, en nuestro caso
haremos la implementación de una lista ordenada, donde
el orden lo determina el atributo id de cada persona.
Antes de iniciar con la codificación debemos analizar las
diferentes situaciones de una eventual inserción:
Desarrollemos la 1. La lista está vacía.

clase Lista 2. La persona a insertar tiene un id menor al que

referencia la cabeza (el primero y menor de la lista),
(sólo creamos el 3.
por lo que se debe insertar a la izquierda de la cabeza.
La lista sólo tiene un elemento y se debe insertar la
atributo y el nueva persona a la derecha de la cabeza.

método inserta) 4. Si no se tienen las condiciones anteriores entonces se

debe insertar en el medio o al final de la lista.

Para cada una de estas situaciones haremos una

codificación separada (en el mismo orden del análisis).
13
1.- Inserta cuando la lista está vacía
• Nos damos cuenta que la lista está vacía cuando el
atributo cabeza es igual a null, si esto es así entonces
sólo basta hacer cabeza igual al nuevo Nodo.

cabeza cabeza

next
Persona (id=10, dato
nombre=“Juan”)
Persona (id=10,
nombre=“Juan”)

p
Hagamos la primer condición y comparamos.

Es un if…

cabeza cabeza

next
Persona (id=10, dato
nombre=“Juan”)
Persona (id=10,
nombre=“Juan”)

p
2.- Si lo que inserto debe ir a la
izquierda de cabeza (p.id es menor)
• Si el elemento a insertar tiene un id menor que el que
referencia cabeza, entonces se debe colocar a la
izquierda de cabeza y redefinir cabeza para que apunte
al nuevo elemento.

cabeza cabeza

p
next next next
dato dato dato
Persona (id=5, Persona (id=10, Persona (id=5, Persona (id=10,
nombre=“Pedro”) nombre=“Juan”) nombre=“Pedro”) nombre=“Juan”)
Hagamos la segunda condición y comparamos.

Es un else if…

cabeza p aux cabeza

p
next (9) next next
dato dato dato
Persona (id=5, Persona (id=10,
Persona (id=5, Persona (id=10,
nombre=“Pedro”) nombre=“Juan”)
nombre=“Pedro”) nombre=“Juan”)

aux cabeza 0)
(1 cabeza

next next next next

dato dato dato dato
Persona (id=5, Persona (id=10, (11) Persona (id=5, Persona (id=10,
nombre=“Pedro”) nombre=“Juan”) nombre=“Pedro”) nombre=“Juan”)
3.- La lista tiene un elemento y se
debe insertar a la derecha de
cabeza.
• Una alternativa de la situación 2 es que la lista sólo tenga
un elemento (cabeza.getNext()==null) y la nueva persona
se deba insertar a la derecha de cabeza.

cabeza cabeza
p
next next next
dato dato dato
Persona (id=10, Persona (id=15, Persona (id=10, Persona (id=15,
nombre=“Juan”) nombre=“Pedro”) nombre=“Juan”) nombre=“Pedro”)
Hagamos la tercera condición y comparamos.

Es un else if…

cabeza cabeza
p
next next next
dato (14) dato dato
Persona (id=15,
Persona (id=10, Persona (id=10, Persona (id=15,
nombre=“Pedro”
nombre=“Juan”) nombre=“Juan”) nombre=“Pedro”)
)
4.- Se debe insertar en el medio o al
final de la lista.
• Si no se dan las condiciones anteriores, se debe
insertar el nuevo elemento en el medio de la lista o al
final.
• Veamos el proceso detallado en las siguientes
filminas.

p cabeza
5 10 15 20 30
18
 Ubicación
• Para ubicarse adecuadamente, creamos una variable Nodo aux, que
inicia a recorrer desde cabeza, hasta el elemento anterior, donde debo
insertar.
• ¿Porqué el anterior?, para poder hacer los enlaces bien. Si nos
ubicamos en 20, no podemos “recordar” la dirección de 15 y no
podríamos enlazar 15 con 18.
• Por eso preguntamos por aux.getNext().getDato.getId(), preguntamos
por el siguiente.

p cabeza
18 5 10 15 20 30
 Ubicación
• Para ubicarnos, utilizamos un ciclo while, donde en su cuerpo sólo se
avanza aux: “aux=aux.getNext()”
• El ciclo se acaba si el siguiente es nulo, o bien, si el siguiente es
mayor al p.getId(): “aux.getNext().getDato().getDato().getId()<p.getId()”

p cabeza
18 5 10 15 20 30
Hagamos el ciclo que ubica aux adecuadamente

Es el último else… aux inicialmente es cabeza

Primero veamos ¿Cómo se ubica
correctamente?

cabeza
5 10 15 20 30

true 18 p
aux
(17) (22)
Primero veamos ¿Cómo se ubica
correctamente?

cabeza
5 10 15 20 30

true 18 p
aux
(22)
Primero veamos ¿Cómo se ubica
correctamente?

cabeza
5 10 15 20 30

18 p
Acá se sale del ciclo
aux (22)
false
Una vez ubicados, enlazamos el nuevo
nodo
• ¿Cómo hacemos los enlaces, para que se de esto?

15 20 15 20

18 18
aux aux
p p
¿Cómo se hacen los enlaces?

15 20 26 15 20

18 18
aux aux
temp
p 27 p

15 20

18
aux
temp
p
¿Cómo se hacen los enlaces?

28 15 20
15 20
18
18
aux
aux temp
temp p
p
¿Cómo se hacen los enlaces?

cabeza
5 10 15 18 20 30

As
íq
ue
da
Y si es al final, ¿Igual funciona?

cabeza
5 10 15 20 30

40 p
aux
Igual funciona… (21)
false
Y un método adicional. El método
toString()
Hagamos la clase de prueba

• Lec06, método main

lec06
Lec06
Práctica / Tarea
• Desarrolle los métodos
• public boolean existe(int id)
• public void modifica (Persona p)
• public void elimina (int id)
• public Persona extrae(int id)

• En la clase Lista colocamos los métodos iniciales

Práctica / Tarea
 Hasta la próxima.
Nos vemos.
Tema de la siguiente clase: Listas Simples Circulares