Clases e instancias. Algoritmos y Estructuras de Datos I. Clases e instancias. memoria dinámica.

Transcripción

1 Algoritmos Estructuras de Datos I Primer cuatrimestre de 2014 Departamento de Computación - FCEN - UBA Programación imperativa - clase 10 Memoria dinámica listas enlazadas Clases e instancias El paquete java.awt inclue una clase llamada Point, que representa puntos en el plano. Creamos un nuevo punto: Point p; p = new Point(, 4); Este código realiza las s acciones: Crea una variable p del tipo Point. Crea un nuevo objeto del tipo Point (que tendrá los valores 4 en sus coordenadas). Asigna en p una referencia al nuevo objeto recién creado. Gráficamente: p Clases e instancias p El nuevo objeto creado es una instancia de la clase Point. Dentro del nuevo objeto, los datos se almacenan en variables de instancia. Cada vez que creamos una instancia de una clase, se crean las variables asociadas a dicha instancia. 4 Memoria dinámica Los objetos se alojan en una parte de la RAM reservada al proceso denominada memoria dinámica. Las variables se alojan en memoria esática. 1. Para los tipos básicos, las variables contienen el valor del tipo. 2. Para los objetos, las variables contienen referencias a memoria dinámica. El ciclo de vida de las variables es distinto de acuerdo al tipo de memoria. 1. Las variables (en memoria estática) desaparecen de la memoria cuando se cierra el bloque en el cual fueron declaradas. 2. Los objetos se mantienen en memoria dinámica mientras haa alguna variable que los referencie. 4

2 Memoria dinámica Aliasing Consideremos este código: Rectangle caja1 = new Rectangle(0, 0, 100, 200); Rectangle caja2 = caja1; Esto genera que ambas variables referencien al mismo objeto. caja1 0 width 100 caja2 0 height Aliasing Ahora, supongamos que invocamos al método grow que ensancha alarga el rectángulo en cada sentido, con las dimensiones especificadas. Sstem.out.println(caja2.width); caja1.grow(50,50); Sstem.out.println(caja2.width); Si bien llamamos a un método que modificaba a caja1, se modificó también caja2. Estructura de Datos Una estructura de datos es una forma de organizar un conjunto de datos elementales con el objetivo de facilitar su manipulación. Un dato elemental es la mínima información que se tiene en un sistema. Las estructuras de datos generalmente corresponden a organizaciones en memoria (dinámica). Operación básica: pedir memoria (new). No sabemos en qué posición de la memoria se asigna el bloque pedido. caja1 50 width 200 caja2 50 height 00 Esto se debe a que las dos variables referencian al mismo objeto. A esto se lo conoce como aliasing. 7 8

3 Arreglos Solicitamos al inicio la cantidad de memoria para almacenar todos los s. Ventajas? La obtención de s basado en la posición es mu eficiente, implementación sencilla (basta pedir un bloque de memoria lo suficientemente grande). Desventajas? Largo fijo. Queremos una estructura para guardar datos, de largo variable. Idea: Pedir memoria para un por vez guardar una referencia a este. Dónde? En un anterior! Creamos una clase Nodo que guarda el que queremos almacenar un puntero a otro Nodo: class Nodo<T> Nodo<T> ; T ; 9 10 Por ejemplo, creamos tres nodos de la forma: Nodo<Integer> nodo1 = new Nodo<Integer>(); nodo1.=1; Nodo<Integer> nodo2 = new Nodo<Integer>(); nodo2.=2; Nodo<Integer> nodo = new Nodo<Integer>(); nodo.=; Graficamente: nodo1 nodo2 nodo Luego, hacemos que el nodo1 referencie al nodo2 el nodo2 al nodo. El nodo referencia a null para indicar que es el final de la lista: nodo1. = nodo2; nodo2. = nodo; nodo. = null; Gráficamente: nodo1 nodo2 nodo

4 Notemos entonces que con sólo mantener una referencia al primer nodo de la lista, podemos acceder a todos los s: prim 1 2 Aprovechando esto, queremos construir una Lista que responda a las s operaciones: Lista<Integer> l = new Lista<Integer>(); l.imprimir(); //imprime [] l.agregaradelante(2); l.imprimir(); //imprime [2] l.agregaradelante(4); l.imprimir(); //imprime [4 2] l.agregaradelante(2); l.imprimir(); //imprime [2 4 2] l.agregaradelante(8); l.imprimir(); //imprime [ ] 1 14 Sólo mantenemos una referencia al primer nodo, con lo cual una Lista va a estar representada sólo por esta variable: Nodo<T> primero; class Nodo<T> Nodo<T> ; T ; La lista vacía es aquella que no tiene un primer nodo, o dicho de otra manera, que el nodo primero vale null. Todo nodo referencia al nodo en la lista. Si es el último no referencia a ninguno, es decir, su variable vale null. Método imprimir Para imprimir una lista, nos paramos en el primer vamos recorriendo la lista utilizando la referencia al :.. void imprimir() Sstem.out.print("["); NodoInt n = this.primero; while (n!= null) Sstem.out.print(n. + " "); n = n.; Sstem.out.println("]"); 15 16

5 Método agregaradelante Cómo agregamos un al principio de la lista? Necesitamos crear un nuevo Nodo que éste pase a formar parte de la lista. Para agregarlo adelante, debe pasar a ser el primer nodo de la lista, debemos tener cuidado de que su variable apunte al nodo apropiado. void agregaradelante(t ) Nodo<T> nuevo = new Nodo<T>(); nuevo. = ; nuevo. = this.primero; this.primero = nuevo; Esquemas de iteración: arreglo Un esquema de iteración es la estructura algorítmica para recorrer los s de una estructura de datos. En un arreglo, recorremos los s con un ciclo con un índice: int i=0; while( i < arreglo.length ) // hacer algo con arr[i] ++i; Esquemas de iteración: lista En la lista, tenemos que crear una referencia a nodo, que se inicializa con el primer nodo de la lista en cada paso se actualiza con el nodo: Nodo<T> n = lista.primero; while (n!= null) // hacer algo con n. n = n. Este algoritmo puede alterarse para frenar en el último o en un buscado. Método largo Ejercicio: escribir un método int largo() que devuelve el largo de la lista. int largo() int l=0; Nodo<T> n = this.primero; while (n!= null) l++; n = n.; return l; 19 20

6 - Ampliando la clase (1) Qué orden de complejidad tiene la función largo()? Ampliamos la clase agregando una variable de instancia con la cantidad de nodos de la lista: Nodo<T> primero; int nodos; - Ampliando la clase (1) Cambia el constructor... Lista() primero = null; nodos = 0; Tenemos que actualizar el código de los métodos que actualizan la lista! Ampliando la clase (1) Cambia el método agregaradelante... void agregaradelante(int ) Nodo<T> nuevo = new Nodo<T>(); nuevo. = ; nuevo. = this.primero; this.primero = nuevo; ++nodos;... todos los métodos que alteren los nodos de la lista! - Ampliando la clase (1) Cuál es la ventaja de haber agregado esta variable? Ahora el método largo es más eficiente! int largo() return nodos; En la versión anterior, este método tenía complejidad O(n), la versión actual tieme complejidad O(1). Mejoramos la eficiencia de uno de los métodos, sin empeorar el orden del resto (sólo agregamos una instrucción a cada uno). 2 24

7 - Ampliando la clase (2) Cómo es el algoritmo para agregar un al final de la lista? (lo llamamos agregaratras). La representación de listas con una referencia al primer genera una asimetría entre los métodos agregaradelante agregaratras. Agregar al principio es O(1). Agregar al final es O(n), porque tenemos que recorrer toda la lista para localizar el último nodo. - Ampliando la clase (2) Una instancia de ListaInt tiene ahora dos referencias: Solución: Mantener una referencia al último nodo! Nodo<T> primero; Nodo<T> ultimo; Ahora, el método agregaratras no necesita recorrer la lista para ubicar el último nodo, entonces pasa a ser O(1). Tenemos que actualizar los métodos que modifican la lista Listas doblemente enlazadas Cada nodo tiene una referencia al, también una referencia al anterior. 27