Departamento de Ingeniería de Sistemas e Industrial

Presentación del tema: "Departamento de Ingeniería de Sistemas e Industrial"— Transcripción de la presentación:

1 Departamento de Ingeniería de Sistemas e Industrial
Estructuras de datos lineales - Listas Departamento de Ingeniería de Sistemas e Industrial 2015

2 Agenda Abstracción Implementación

3 Agenda Abstracción Implementación

4 Estructuras de datos lineales básicas
Abstracción Listas colas Pilas

5 Tipo de Dato Abstracto (TDA)
Abstracción Datos? Operaciones? Independiente de la implementación computacional!!!

6 Tipo de Dato Abstracto: Lista
Abstracción Tipo de Dato Abstracto: Lista Una secuencia de objetos: A0, A1, A2, ..., AN-1 Definiciones: • Tamaño de la lista: N • Lista vacía: una lista de tamaño 0 • Para cualquier lista (excepto la lista vacía): Ai es el elemento siguiente (o sucesor) de Ai-1 (i<N) Ai-1 precede a Ai (i>0) El primer elemento es A0 El último elemento es AN-1 La posición del elemento Ai en la lista es i

7 Tipo de Dato Abstracto: Lista
Abstracción Tipo de Dato Abstracto: Lista Operaciones: • Imprimir lista (printList) • Vaciar lista (makeEmpty) • Buscar elemento (find) • Insertar elemento en la posición k (insert) • Eliminar elemento de la posición k (remove) • Leer elemento ubicado en la posición k (findKth) Ejemplo: Para la lista 21, 53, 45, 98 find(45) →2 insert(34, 3) → 21, 53, 45, 34, 98 remove(53) → 21, 45, 34, 98

8 Ejemplos de aplicación
Abstracción Ejemplos de aplicación Aplicaciones • Lista de “cosas por hacer” (To Do List): Insertar tareas Borrar las tareas que ya se hayan realizado … Procesadores de texto Insertar texto digitado Borrar texto • Lista de compras Añadir producto Quitar productos que ya se hayan comprado Ordenar por prioridad

9 Agenda Abstracción Implementación

10 Implementación con un arreglo

11 Implementación con un arreglo
primer elemento de la lista elemento (índice 8) índices tamaño de la lista (máximo el tamaño del arreglo)

12 Análisis de la implementación
• Operación Imprimir lista (printList): Tiempo lineal: O(N) • Obtener el elemento k (findKth): Tiempo constante: O(1)

13 Análisis de la implementación
• Insertar un elemento en la posición k (insert): Caso 1: ¿Cómo insertar un nuevo elemento al final de la lista? i) si el arreglo tiene suficiente espacio disponible al final Tiempo constante: O(1) ii) si el arreglo NO tiene suficiente espacio disponible al final Se deben copiar todos los elementos del arreglo a un nuevo arreglo más grande Tiempo lineal: O(N)

14 Análisis de la implementación
• Insertar un elemento en la posición k (insert): Caso 2: ¿Cómo insertar un nuevo elemento en la mitad de la lista? i) si el arreglo tiene suficiente espacio disponible al final Se deben copiar los elementos después del k-ésimo para “abrirle espacio” al nuevo elemento que se va a insertar Tiempo: O(N-k)

15 Análisis de la implementación
• Insertar un elemento en la posición k (insert): Caso 2: ¿Cómo insertar un nuevo elemento en la mitad de la lista? i) si el arreglo NO tiene suficiente espacio disponible al final Se debe crear un nuevo arreglo más grande y se copian todos los elementos al nuevo arreglo! La lista tiene tamaño N+1 después de insertar el nuevo elemento Tiempo lineal: O(N)

16 Análisis de la implementación
Insertar un elemento en la posición k (insert): Caso 2: ¿Cómo insertar un nuevo elemento en la mitad de la lista? i) si el arreglo NO tiene suficiente espacio disponible al final

17 Análisis de la implementación
• Eliminar elemento de la posición k (remove) ¿cómo se elimina un elemento intermedio? Se deben “mover hacias atrás” (copiar) los elementos después del k-ésimo La lista tiene tamaño N-1 después de eliminar el elemento

18 Análisis de la implementación
Mejores casos (más baratos!) Insertar elemento en la última posición? → O(1) Eliminar el elemento en la última posición? → O(1) (si el arreglo tiene espacio disponible) Peores casos (más costosos!) Insertar en la posición 0? → O(N) Eliminar el elemento en la posición 0? → O(N)

19 Análisis de la implementación
En muchas situaciones tan sólo se necesita hacer inserciones al final de la lista y búsquedas de elementos Los arreglos son una implementación viable Pero, ¿si se requiere hacer inserciones y eliminaciones a lo largo de la lista, y, en particular, al principio? Los arreglos NO son una implementación eficiente Se pueden utilizar entonces listas enlazadas

20 Implementación con una lista encadenada (enlazada)

21 Implementación con una lista encadenada (enlazada)
Listas enlazadas simples • La lista está formada por un conjunto de nodos que no necesariamente están almacenados en posiciones consecutivas en la memoria. • Cada nodo contiene un elemento de la lista y un enlace al nodo siguiente. cabeza null

22 Implementación Implementación Nodo: dos campos Se debe mantener una variable head que siempre apunta al primer nodo en la lista, o es null para una lista vacía. data next record Node { data // Los datos almacenados en el nodo Node next // Una referencia al nodo siguiente, null para el último nodo } record List { Node head // points to the head of the list; null for empty list

23 Implementación . . . Operaciones Recorrer la lista (traverse)
Empezar en el primer nodo y seguir hasta llegar al final node := list.head while node not null (do something with node.data) node := node.next node . . . cabeza

24 Implementación Operaciones: Insertar elemento en la posición k(insert)
cabeza

25 Implementación Operaciones:
Insertar un nodo después de un nodo existente en la lista function insertAfter(Node node, Node newNode) // insert newNode after node newNode.next := node.next node.next := newNode Insertar nodo al comienzo requiere actualizar el primer nodo de la lista. function insertBeginning(Node newNode) // insert node before current first node newNode.next := head list.head := newNode

26 Implementación Operaciones:
Eliminar elemento de la posición k (remove) cabeza

27 Implementación Operaciones: cabeza Implementación
Remover un nodo después de un nodo dado Al remover el primer nodo de la lista se debe actualizar head Para encontrar y remover un nodo particular se debe guardar el anterior elemento al que se va a eliminar removeAfter(Node node) // remove node past this one obsoleteNode := node.next node.next := node.next.next destroy obsoleteNode function removeBeginning(List list) // remove first node obsoleteNode := list.head list.head := list.head.next // point past deleted node destroy obsoleteNode cabeza

28 Análisis de la implementación
cabeza Operaciones: Imprimir lista (printList) → O(N) Leer el elemento k (findKth) → O(k)

29 Análisis de la implementación
Operaciones: Insertar elemento en la posición k(insert) → O(k) cabeza

30 Análisis de la implementación
Operaciones: Eliminar elemento de la posición k (remove) → O(k) cabeza

31 Implementación con una lista doblemente encadenada (doblemente enlazada)

32 Implementación con una lista doblemente encadenada (enlazada)
cabeza cola

33 Implementación Implementación Nodo: tres campos Se deben mantener dos variables head y tail que siempre apuntan al primero y al último nodo en la lista, o tienen valor null para una lista vacía. data next previous record Node { data // Los datos almacenados en el nodo Node next // Una referencia al nodo siguiente, null para el último nodo Node previous// Una referencia al nodo anterior, null para el primer nodo } record DoubleLinkedList { Node head // points to the head of the list; null for empty list Node tail // points to the tail of the list; null for empty list

34 Análisis de la implementación
cabeza cola Buscar un dato en la lista → O(N) Buscar dato en la posición k(find) → O(N/2) Insertar elemento en la posición k (insert) → O(N/2) Eliminar elemento de la posición k (remove) → O(N/2) Leer elemento ubicado en la posición k (findKth) → O(N/2)

35 Implementación con una lista encadenada simple circular

36 Implementación con una lista enlazada simple circular
cabeza

37 Implementación Implementación Nodo: dos campos Se debe mantener una variable head que siempre apunta al primer nodo en la lista, o es null para una lista vacía. El último nodo apunta al primer nodo de la lista data next cabeza

38 Implementación data next record Node {
data // Los datos almacenados en el nodo Node next // Una referencia al nodo siguiente, head para el último nodo } record List { Node head // points to the head of the list; null for empty list

39 Análisis de la implementación
cabeza Buscar elemento (find) → O(?) Insertar elemento en la posición k (insert) → O(?) Eliminar elemento de la posición k (remove) → O(?) Leer elemento ubicado en la posición k (findKth) → O(?)

40 Implementación con una lista doblemente encadenada circular

41 Implementación con una lista doblemente enlazada circular
cabeza cola

42 Implementación Implementación Nodo: tres campos Se deben mantener dos variables head y tail que siempre apuntan al primero y al último nodo en la lista, o tienen valor null para una lista vacía. data next previous cabeza cola

43 Implementación data next previous Implementación record Node {
data // Los datos almacenados en el nodo Node next // Una referencia al nodo siguiente, head para el último nodo Node previous// Una referencia al nodo anterior, tail para el primer nodo } record DoubleLinkedList { Node head // points to the head of the list; null for empty list Node tail // points to the tail of the list; null for empty list

44 Implementación Recorrer la lista (traverse) Implementación
record DoublyLinkedNode { previous // A reference to the previous node next // A reference to the next node data // Data or a reference to data } record DoublyLinkedList { DoublyLinkedNode head// points to first node of list DoublyLinkedNode tail// points to last node of list Recorrer la lista (traverse) Se puede recorrer en cualquier dirección Hacia adelante (Forwards) node := list.head while node ≠ null <do something with node.data> node := node.next Hacia atrás (Backwards) node := list.tail node := node.previous

45 Implementación Insertar un nodo Implementación
insertAfter(List list, Node node, Node newNode) { newNode.previous := node newNode.next := node.next if node.next == null list.tail := newNode else node.next.previous := newNode node.next := newNode }

46 Implementación Insertar un nodo Implementación
Insertar un nodo al comienzo de una lista posiblemente vacía: function insertBeginning(Node newNode) if list.head == null list.head := newNode list.tail := newNode newNode.previous := null newNode.next := null else insertBefore(list.tail, newNode) Una función “simétrica” inserta al final: function insertEnd(Node newNode) if list.tail == null insertBeginning(newNode) insertAfter(list.tail, newNode)

47 Implementación Remover un nodo Implementación
Es más fácil que la inserción, pero requiere manejo especial cuando el nodo a remover es el primero o el último ( head o tail) function remove(Node node) { if node.previous == null list.head := node.next else node.previous.next := node.next if node.next == null list.tail := node.previous else node.next.previous := node.previous }

48 Análisis de la implementación
cabeza cola Buscar elemento (find) → O(?) Insertar elemento en la posición k (insert) → O(?) Eliminar elemento de la posición k (remove) → O(?) Leer elemento ubicado en la posición k (findKth) → O(?)

49 Comparación de las implementaciones
Implementación Comparación de las implementaciones Arreglo Lista encadenada Lista encadenada simple circular Lista doblemente encadenada Indexación O(1) O(N) ?? Insertar/borrar al comienzo No aplica Insertar/borrar al final O(N) cuando se desconoce el ultimo elemento; O(1) cuando se conoce el ultimo elemento Insertar/borrar en el medio Tiempo de búsqueda + O(1) Espacio “desperdiciado”