Estructuras de Datos y Algoritmos TDA LISTA. Metáfora del TDA (repaso) Conjunto de operaciones forman una pared forman una interfase entre los programas.

Presentación del tema: "Estructuras de Datos y Algoritmos TDA LISTA. Metáfora del TDA (repaso) Conjunto de operaciones forman una pared forman una interfase entre los programas."— Transcripción de la presentación:

1 Estructuras de Datos y Algoritmos TDA LISTA

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

3 Diseño de una Clase (repaso)

4 ¿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

5 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)

6 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

7 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

8 ¿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

9 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

10 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 add

11 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

12 Ilustración de add(3,44) k numItems 12319100...510¿?...¿? 0 1 2 3... K-1 MAX Índices del arreglo 1 2 3 4 k Posiciones del TDA 44

13 Ilustración de add(3,44) k numItems 12319100...510¿?...¿? 0 1 2 3... K-1 MAX Índices del arreglo 1 2 3 4 k Posiciones del TDA 44

14 Ilustración de add(3,44) k numItems 12319100...510...¿? 0 1 2 3... K-1 MAX Índices del arreglo 1 2 3 4 k Posiciones del TDA 44

15 Ilustración de add(3,44) k numItems 12319100...510...¿? 0 1 2 3... K-1 MAX Índices del arreglo 1 2 3 4 k Posiciones del TDA 44

16 Ilustración de add(3,44) k numItems 12319100...5510...¿? 0 1 2 3... K-1 MAX Índices del arreglo 1 2 3 4 k Posiciones del TDA 44

17 Ilustración de add(3,44) k numItems 12319...100510...¿? 0 1 2 3... K-1 MAX Índices del arreglo 1 2 3 4 k Posiciones del TDA 44

18 Ilustración de add(3,44) k numItems 1234419...100510...¿? 0 1 2 3... K-1 MAX Índices del arreglo 1 2 3 4 k Posiciones del TDA 44

19 Ilustración de add(3,44) k numItems 1234419...100510...¿? 0 1 2 3... K-1 MAX Índices del arreglo 1 2 3 4 k Posiciones del TDA 44 Sumar 1

20 Ilustración de add(3,44) K+ 1 numItems 1234419...100510...¿? 0 1 2 3... K-1 MAX Índices del arreglo 1 2 3 4 k Posiciones del TDA

21 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

22 Listas enlazadas TDA Nodo Un Nodo es un par información y vínculo al próximo nodo con las siguientes 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 inf o

23 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

24 Listas enlazadas Implantación

25 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( "List index out of bounds exception on get"); } // end if } // end get

26 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

27 Insertar nodos ilustración

28 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

29 Borrar nodos ilustración

30 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

31 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

32 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

33 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