Estructuras de Datos y Algoritmos TDA LISTA. Metáfora del TDA (repaso) Conjunto de operaciones...

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

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

k

numItems

12 3 19 100 ... 5 10 ¿? ... ¿?

0 1 2 3 ... K-1 MAX

Índices del arreglo

1 2 3 4 k

Posiciones del TDA 44


k

numItems

12 3 19 100 ... 5 10 10 ... ¿?

0 1 2 3 ... K-1 MAX


1 2 3 4 k



k

numItems

12 3 19 100 ... 5 5 10 ... ¿?

0 1 2 3 ... K-1 MAX


1 2 3 4 k



k

numItems

12 3 19 19 ...100 5 10 ... ¿?

0 1 2 3 ... K-1 MAX


1 2 3 4 k



k

numItems

12 3 44 19 ...100 5 10 ... ¿?

0 1 2 3 ... K-1 MAX


1 2 3 4 k



k

numItems

12 3 44 19 ...100 5 10 ... ¿?

0 1 2 3 ... K-1 MAX


1 2 3 4 k


Sumar 1


K+1

numItems

12 3 44 19 ...100 5 10 ... ¿?

0 1 2 3 ... K-1 MAX


1 2 3 4 k

Posiciones del TDA

Ventajas y Desventajasde 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 enlazadasTDA 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

info

Listas enlazadasImplantació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(

"List index out of bounds exception on get");

} // end if

} // end 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 nodosilustració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 nodosilustració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


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


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


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

Estructuras de Datos y Algoritmos TDA LISTA. Metáfora del TDA (repaso) Conjunto de operaciones...

Documents

Transcript of Estructuras de Datos y Algoritmos TDA LISTA. Metáfora del TDA (repaso) Conjunto de operaciones...