.

1. TDA LISTA
Estructuras de Datos
CCPG1006

2. Objetivos
• Aprovechar la abstracción para definir comportamiento y luego
operaciones en nivel de implementación
• Visualizar las posibles implementaciones de un TDA ya definido
• Describir y dibujar la estructura de un LinkedList
• Describir la ventaja de usar LinkedList en lugar de ArrayList

3. TDA Lista
Definición
• Colección de 0 o más elementos
– Si la lista no tiene elementos, se dice que esta vacía
– Todos los elementos son de un mismo tipo
• Estructuras lineales
– Cada elemento de una lista se conoce con el nombre de NODO
– Los nodos están colocados uno detrás de otro
• Las listas
– Son mucho más flexibles que los arreglos
– Permiten trabajo “dinámico” con un grupo de elementos
– Crecen y se contraen a medida que se ejecuta el programa

4. Lista
Nivel lógico
• Comportamiento (a/con una lista se puede)
– Crear y Eliminar
– Conocer si esta vacía
– Añadir elementos y removerlos
– Consultar el primer y al último elemento
– Imprimir sus elementos en pantalla
– Buscar un elemento con cierta información en la lista

5. TDA Lista
Tipos de listas
• De acuerdo a su implementación, las listas se clasifican en:
– Simplemente Enlazadas
– Doblemente Enlazadas
– Circulares (Simplemente y Doblemente Enlazadas)

6. TDA Lista
Implementación
• Tenemos el concepto claro de lo que debe ser una lista
• ¿Cómo darle vida a una lista?
• Hay varias posibilidades de implementación
– Estática o Contigua, usando arreglos de longitud “variable” (ArrayList
en Java)
– Dinámica (LinkedList en Java)

7. TDA Lista
Java - Interfaz List
En java la interfaz List corresponde a la descripción del TDA Lista

8. TDA Lista
Java - Interfaz List

9. TDA Lista
Recordar
Interfaz especifica el comportamiento pero no la implementación

10. Implementación continua
ArrayList
• Utilizar un arreglo para implementar la interfaz List
– Secuencia de elementos
– Elementos continuos y adyacentes en memoria
– Cada elemento tiene un índice
• Se puede acceder directamente a una ubicación en particular
mediante el índice del arreglo
– Tiempo de acceso constante
• Al insertar o remover un elemento,
– Todos los elementos restantes avanzarán o retrocederán

11. 10
0
5
1
8
2
2
3
31
4 5 6 7 8
En uso Desperdicio
25Al insertarse un
nuevo elemento,
en una cierta
posición, todos los
elementos
restantes ruedan
25
3
2
4 5 6 7 8
31
size
Capacidad
ensureCapacity
ArrayList

12. • ¿Cuánto tiempo toma recuperar un elemento de un ArrayList ?
• ¿Cuánto tiempo toma insertar un elemento al inicio de un ArrayList?
– O(1)?
– O(n)?
– O(n2)? t
O(f)
ArrayList

13. • El tiempo que toma recuperar un elemento en la implementación de
ArrayList es O(1)
– Los elementos están almacenados de forma continua en memoria
– Pueden ser accedidas con un índice que accede directamente a
cualquier elemento a un tiempo constante
• Para insertar un elemento, debe mover todos los valores siguientes. El
tiempo que se gasta copiando todos los valores depende linealmente del
tamaño del arreglo original
– O(n)
ArrayList

14. • ArrayList implementa List
• Un TDA no especifica la eficiencia con la que se debe implementar
• La Estructura de Dato que implementa el TDA establece la eficiencia en la
forma que lo hace
– ArrayList no es eficiente para insertar un nuevo elemento.
– ArrayList es eficiente para acceder elemento.
ArrayList

15. TDA Lista
Recordar
Interfaz especifica el comportamiento pero no la implementación
Doblemente Enlazadas

16. Diferencia entre usar ArrayList y
LinkedList
• ArrayList es eficiente para acceder a los
elementos.
• LinkedList es eficiente para agregar elementos.
• ArrayList y LinkedList tienen costos adicionales
para remover elementos.

17. • Cada nodo de la lista tiene
– Un contenido
• Información que almacena dentro y puede ser de cualquier tipo
de dato
– Un sucesor único
• Excepto el último nodo de la lista que hace referencia a null
<listaSimple> ::= <inicial> + {<ref_nodo>} + <final>
<inicial> ::= <enlace>
<final> ::= <enlace>
Lista Simplemente Enlazada
(memoria no adyacente)

18. • Es una implementación flexible y potente
• Los nodos ya no son adyacentes en memoria
– Un nodo A logra un enlace con otro B,
– Almacenando dentro la dirección de memoria de B
• Al insertar o eliminar un nodo ya no hay que “mover” al resto de
elemento, solo enlazarlo con la lista
Contenido Enlace
e n
e n
NODO A
NODO B
Lista Simplemente Enlazada
(memoria no adyacente)

19. 10 5 8 2 31
25
25
2 3125
Lista Simplemente Enlazada
(memoria no adyacente)

20. TDA Nodo
Definición
• Una lista esta compuesta de nodos, y por eso es importante definir el
TDA Node
• Un nodo de una lista
– Almacena información de cualquier tipo
– Es capaz de “viajar” o conocer otro nodo (el nodo siguiente)
• Comportamiento
– Crear y Eliminar
– Consultar y modificar la información que almacena
– Consultar y modificar el enlace que mantiene con otro nodo
<nodo> ::= <contenido> + <enlace>
<contenido> ::= <dato>{<dato>}
<enlace> ::= <ref_nodo> | <ref_null>

21. • Contenido: Datos enteros, reales, o incluso, de Tipo: Estudiante, Auto,
etc....
• Y además, el nodo también contiene un enlace con su nodo siguiente
• Este enlace, puede no enlazar el nodo con nadie, el nodo esta solo, no forma
parte de ninguna lista
• O puede “apuntar” a otro nodo, indicando que ese es su siguiente, formando
una Lista
TDA Nodo
Nivel de implementación

22. TDA Nodo
• Un nodo almacena dentro
– Un contenido de cualquier tipo de dato, entero, real, estructuras,
etc......
– Un enlace, que es la referencia al nodo siguiente, la dirección del
nodo siguiente
• Una posible implementación sería:

23. TDA Nodo
Nivel de implementación
Crear
Node();
Consultar y Modificar Contenido
Object getData();
Consultar y Modificar Enlaces
Node getNext();
void setNext(Node n);

24. Nodo
Crear un nuevo nodo
Al crear un nodo se le asignará un valor inicial

25. Lista Simplemente Enlazada
Nivel de implementación
Llevar control de las posiciones al primer y el último elemento
Las posiciones son direcciones de memoria: referencias
head y tail ( primero y último) son referencias a Node en una lista
enlazada
La posición de un nodo estará dada por una referencia a dicho nodo
Una lista enlazada no tiene datos predefinidos
Los elementos o Nodos van siendo creados y eliminados a medida
que se va necesitando

26. Hay varias formas de definir una lista
– Solo a través del primer elemento a la misma
– Llevando control del primero y el último elemento,
– Almacenando el número de nodos y referencias al inicio y fin
– otros
Lista Simplemente Enlazada
Implementación

27. Lista Simplemente Enlazada
Operaciones
• Crear
– SimpleLinkedList()
• Consultar Primer y Ultimo
– NodeList getFirst();
– NodeList getLast();
• Conocer Estado
– bool isEmpty();
• Añadir y Remover
– bool insertFirst(NodeList node);
– bool insertLast(NodeList node);
– bool insert(NodeList node, NodeList newNode);
– NodeList removeFirst();
– NodeList removeLast();
– bool removeNode(NodeList node);
• Busqueda
– NodeList search(Object o);
– bool exist(NodeList node);

28. Lista Simplemente Enlazada
Búsqueda
• Hay que ubicarse en el inicio: first
• E ir avanzando hasta
– Encontrar el nodo con la información buscada
o
– Que ya no haya más nodos
• Como no se usan índices, se usan
referencias:
– Una referencia se ubicará en el primero
– Avanzar al siguiente, y al siguiente y al
siguiente
• Al encontrar al nodo buscado, no se retorna
su posición como índice, esta no importa, se
retorna la referencia (dirección) de este
nodo
10 5 8 2 3125
lastfirst
Busco 25
p p p pp
Busco 30
p p p p p
p

29. Lista Simplemente Enlazada
Anterior
• Dada la dirección de un nodo(pos), esta función retorna la dirección del nodo
anterior
• Hay que “buscar” desde el inicio
• El nodo buscado es aquel cuyo siguiente es igual a pos
• Si el elemento buscado es el primero en la lista, no hay anterior
10 5 8 2 3125
lastfirst
pq q q
7
p
La posición
p es la de
un nodo
fuera de la
lista
q q q q q q
q

30. Lista Simplemente Enlazada
Primero y Último
• Se pueden obtener siempre y cuando la lista no este vacía
• Retornan la información del elemento apuntado por first y last
respectivamente.

31. Lista Simplemente Enlazada
Insertar
• La operación de insertar recibirá
– El NODO que se va a insertar
– Este nodo ya debió haber sido creado antes de insertarlo
• Hay varios tipos de inserción
– Insertar al inicio o al final
– Insertar en medio de la lista

32. 10 5 8 2 3125
lastfirst
Lista Simplemente Enlazada
Inserción al inicio/final
9
nuevo
first
nuevo.next = first;
first = nuevo;
18
nuevo
last.next = nuevo;
last
last = nuevo;
Si la lista esta vacía, tanto first como last apuntan al nuevo nodo
Si no, si es al inicio el nuevo valor de first, es el nuevo nodo
Si no, si es al final, el nuevo valor de last es el nuevo nodo

33. Lista Simplemente Enlazada
Insertar en medio
• Debe recibir la posición donde se
va a insertar
• Insertemos después
– Si la posición no existe no
efectuar la inserción
– Si la lista solo tiene un
elemento, el nuevo last es el
nuevo nodo
10 5 8 2 3125
first lastp
18
newNode
newNode.next = p.next;p.next = newNode;

34. Lista Simplemente Enlazada
Remover de la lista (inicio o al final)
La lista no debe estar vacía!!, si tiene un solo elemento, dejarla vacía
10 5 8 2 3125
first last
tmp
tmp = first;
first
first = first.next;
tmp
tmp = last;
last
last = previous(last);
last.next = null;
tmp.next = null;

35. Lista Simplemente Enlazada
Remover un nodo
• Lista no debe estar vacía
• La posición enviada debe existir
en la lista
• Revisar si se desea eliminar el
first o el last
10 5 8 2 3125
first lastp
prevprev = getPrevious(p);
prev.next = p.next;
p.next = null;

36. Lista Simplemente Enlazada
Visualizar
Imprimir todos los nodos de la lista
void print(){
NodeList temp;
for(temp = this.first; temp != null; temp = temp.next)
System.out.println(temp.data);
}

37. Lista Simplemente Enlazada
Operaciones
• Crear
– SinglyLinkedList()
• Consultar primero, último y tamaño
– E first();
– E last();
– int size();
• Conocer Estado
– bool isEmpty();
• Añadir y Remover
– void addFirst(E e);
– void addLast(E e);
– bool add(int i, E e);
– E removeFirst();
– E removeLast();
• Búsqueda
– int indexOf(E e);
– bool contains (E e);