Estructuras de Datos y Algoritmos TDA LISTA

Estructuras de Datos y Algoritmos TDA LISTA

Metáfora del TDA (repaso) Conjunto de operaciones forman una pared forman una interfase entre los programas y la estructura de datos

Diseño de una Clase (repaso)

Qué es una Lista? Ejemplo 1. ARENAS ALICEA, ALEXIS 2. CASANOVA DEL MORAL, LISA R 3. COLON VELEZ, MIGUEL A 4. GAMBOA NIEVES, EXEL 5. HERNANDEZ VIERA, MARIAN 6. JAIME COLLAZO, ASTRID M 7. MEDINA RIVERA, LUIS A 8. MUNOZ HERNANDEZ, JOSE L 9. NAVARRO LOPEZ, AIDA Y. 10. PASSAPERA SANCHEZ, LIANETTE 11. QUILES LOPEZ, JUAN 12. REYES COLON, JUAN C 13. REYES TORRES, JENNY 14. ROSADO MILLAN, ARELIS 15. SANTIAGO APONTE, MARIA M 16. TORRES VELAZQUEZ, DORCI LEE

Abstracción Características que tiene toda lista: tiene algo o está vacía si tiene algo... Tiene una cantidad finita de elementos Tiene un primer elemento tiene un último elemento cada elemento tiene una posición cada elemento tiene un sucesor (excepto el último) cada elemento tiene un predecesor (excepto el primero)

TDA Lista Una Lista es una colección lineal de objetos con las siguientes operaciones: crear una lista vacía detrminar si la lista está vacía determinar cantidad de elementos añadir item en determinada posición elininar iten de determinada posición ver el item en una posición dada

Interfaces una manera de representar un TDA en Java public interface ListInterface { public boolean isempty(); public int size(); public void add(int index, Object item); public Object get(int index) ; public void remove(int index); public void removeall(); } // end ListInterface

Qué falta? Estructura de Datos hay distintas opciones podemos seleccionar un arreglo para guardar los items y un entero para saber cuantos items hay Algoritmos dependen de la ED que se haya seleccionado

Una implantación con arreglos public class ListArrayBased implements ListInterface { private static final int MAX_LIST = 50; private Object items[]; // an array of list items private int numitems; // number of items in list public ListArrayBased() { items = new Object[MAX_LIST]; numitems = 0; } // end default constructor

public boolean isempty() {return (numitems == 0);} public int size() {return numitems;} // end size public void add(int index, Object item) { if (numitems <= MAX_LIST) { if (index >= 1 && index <= numitems+1) { for (int pos = numitems; pos >= index; pos--) { items[translate(pos+1)] = items[translate(pos)]; } // end for items[translate(index)] = item; numitems++; } } // end if } // end if } //end add

public Object get(int index) { if (index >= 1 && index <= numitems) { return items[translate(index)]; } // end if } // end get public void remove(int index) { if (index >= 1 && index <= numitems) { for (int pos = index+1; pos <= size(); pos++) { items[translate(pos-1)] = items[translate(pos)]; } // end for numitems--; } // end if } //end remove } // end ListArrayBased

Ilustración de add(3,44) Índices del arreglo numitems k 0 1 2 3... K-1 MAX 12 3 19 100... 5 10?...? 1 2 3 4 k osiciones del TDA 44

Ilustración de add(3,44) Índices del arreglo numitems k 0 1 2 3... K-1 MAX 12 3 19 100... 5 10?...? 1 2 3 4 k osiciones del TDA 44

Ilustración de add(3,44) Índices del arreglo numitems k 0 1 2 3... K-1 MAX 12 3 19 100... 5 10 10...? 1 2 3 4 k osiciones del TDA 44

Ilustración de add(3,44) Índices del arreglo numitems k 0 1 2 3... K-1 MAX 12 3 19 100... 5 10 10...? 1 2 3 4 k osiciones del TDA 44

Ilustración de add(3,44) Índices del arreglo numitems k 0 1 2 3... K-1 MAX 12 3 19 100... 5 5 10...? 1 2 3 4 k osiciones del TDA 44

Ilustración de add(3,44) Índices del arreglo numitems k 0 1 2 3... K-1 MAX 12 3 19 19 100... 5 10...? 1 2 3 4 k osiciones del TDA 44

Ilustración de add(3,44) Índices del arreglo numitems k 0 1 2 3... K-1 MAX 12 3 44 19 100... 5 10...? 1 2 3 4 k osiciones del TDA 44

Ilustración de add(3,44) Índices del arreglo Sumar 1 numitems k 0 1 2 3... K-1 MAX 12 3 44 19 100... 5 10...? 1 2 3 4 k osiciones del TDA 44

Ilustración de add(3,44) Índices del arreglo numitems K+1 0 1 2 3... K-1 MAX 12 3 44 19 100... 5 10...? 1 2 3 4 k osiciones del TDA

Ventajas y Desventajas de la implantación de listas con arreglos Ventajas relativamente fácil ED arrego es parecido a TDA lista Desventajas se llena hay que estar rodándolo

Listas enlazadas TDA Nodo Un Nodo es un par información y vínculo al próximo nodo con las siguientes info operaciones: constructor setitem(x): pone x en el campo de información setnext(n): pone n en el vínculo al próximo getitem(): devuelve campo de información getnext(): devuelve referencia al próximo

Listas enlazadas Implantación de Nodo public class Node { private Object item; private Node next; public Node(Object newitem) { item = newitem; next = null; } // end constructor public Node(Object newitem, Node nextnode) { item = newitem; next = nextnode; } // end constructor public void setitem(object newitem) { item = newitem; } // end setitem public Object getitem() { return item; } // end getitem public void setnext(node nextnode) { next = nextnode; } // end setnext public Node getnext() { return next; } // end getnext } // end class Node

Listas enlazadas Implantación

public class ListReferenceBased implements ListInterface { // reference to linked list of items private Node head; private int numitems; // number of items in list //c ListReferenceBased(), isempty(), size() private Node find(int index) { Node curr = head; for (int skip = 1; skip < index; skip++) { curr = curr.getnext(); } // end for return curr; } // end find public Object get(int index) { if (index >= 1 && index <= numitems) { } // get reference to node, then data in node Node curr = find(index); Object dataitem = curr.getitem(); return dataitem; else { System.out.println( } // end if } // end get "List index out of bounds exception on get");

public void add(int index, Object item) { if (index >= 1 && index <= numitems+1) { if (index == 1) { // insert the new node containing item at // beginning of list Node newnode = new Node(item, head); head = newnode; } else { Node prev = find(index-1); // insert the new node containing item after // the node that prev references Node newnode = new Node(item, prev.getnext()); prev.setnext(newnode); } // end if numitems++; } else { System.out.println( "List index out of bounds exception on add"); } // end if } // end add

Insertar nodos ilustración

public void remove(int index) { if (index >= 1 && index <= numitems) { if (index == 1) { // delete the first node from the list head = head.getnext(); } else { Node prev = find(index-1); // delete the node after the node that prev // references, save reference to node Node curr = prev.getnext(); prev.setnext(curr.getnext()); } // end if numitems--; } // end if else { System.out.println("List index out of bounds exception on remove"); } // end if } // end remove

Borrar nodos ilustración

Análisis de ambas implantaciones Con Arreglos. Suponer que hay N elementos en la lista añadir(k,x) hay que rodar los que están de k en adelante el peor caso es cuando k=1 en ese caso hay que mover N cosas hay otras 4 instrucciones fuera del ciclo total de instrucciones en el peor caso: N+4

Análisis de ambas implantaciones Con Arreglos Delete(k) hay que rodar los elementos desde después de la posición k el peor caso es k=1 en ese caso hay que mover N-1 cosas hay otras 2 instrucciones fuera del ciclo total de instrucciones en el peor caso: N+1

Análisis de ambas implantaciones Con listas enlazadas Add(k,x) hay moverse de nodo en nodo hasta la posición k el peor caso es k=n en ese caso hay que moverse N-1 veces hay otras 3 instrucciones fuera del ciclo total de instrucciones en el peor caso: N+2

Análisis de ambas implantaciones Con listas enlazadas Remove(k,x) hay moverse de nodo en nodo hasta la posición k el peor caso es k=n en ese caso hay que moverse N-1 veces hay otras 3 instrucciones fuera del ciclo total de instrucciones en el peor caso: N+2