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

Agenda Abstracción Implementación

Agenda Abstracción Implementación

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

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

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

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

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

Agenda Abstracción Implementación

Implementación con un arreglo

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)

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

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)

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)

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)

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

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

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)

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

Implementación con una lista encadenada (enlazada)

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

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

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

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

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

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

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

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

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

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

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

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

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

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)

Implementación con una lista encadenada simple circular

Implementación con una lista enlazada simple circular cabeza

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

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

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(?)

Implementación con una lista doblemente encadenada circular

Implementación con una lista doblemente enlazada circular cabeza cola

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

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

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

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 }

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)

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 }

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(?)

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”