Estructura de Datos y de la Información

Transcripción

1 Universidad Rey Juan Carlos Curso 2009/10 Ingeniería Técnica en Informática de Gestión Estructura de Datos y de la Información Examen Final Junio 2010 Fecha: Soluciones Ejercicio 1. (Puntuación total: 6 puntos) (a) (1,5 puntos) ESPECIFICACIÓN ListasJunio10 PARÁMETROS GENÉRICOS Combina: TipoElemento x TipoElemento -> TipoElemento FIN PARÁMETROS USA Listas (* constructoras no generadoras *) PARÁMETROS GENÉRICOS Relación: TipoElemento x TipoElemento -> Booleano FIN PARÁMETROS Transforma: TipoLista -> TipoLista PARCIAL CombinaListas: TipoLista x TipoLista -> TipoLista (* auxiliares *) PARCIAL BorrarUltimo: TipoLista -> TipoLista VARIABLES e, e1, e2: TipoElemento; lista, lista1, lista2: TipoLista; n: Natural; ECUACIONES DE DEFINITUD SI Longitud(lista1) = Longitud(lista2) -> DEF(CombinaListas(lista1,lista2)) DEF(BorrarUltimo(Construir(e,lista))) ECUACIONES Transforma(CrearVacía) = CrearVacía Transforma(Construir(e,CrearVacía)) = Construir(e1,CrearVacía) Transforma(Construir(e1,Construir(e2,lista))) = SI Relacion(e1,e2) -> Construir(Combina(e1,e2),Transforma(Construir(e2,lista))) Construir(e1,Transforma(Construir(e2,lista)) CombinaListas(CrearVacía,CrearVacía) = CrearVacía CombinaListas(Construir(e,lista1), lista2)) = Construir(Combina(e,Ultimo(lista2)), CombinaListas(lista1,BorrarUltimo(lista2))) BorrarUltimo(Construir(e,lista)) = SI EsVacia(lista) -> CrearVacía Construir(e,BorrarUltimo(lista)) FIN ESPECIFICACIÓN. 1

2 (b) (0,5 puntos) GENERIC WITH FUNCTION Combina(e1, e2: TipoElemento) RETURN TipoElemento; PACKAGE Listas.Junio10 IS DistintaLongitud: EXCEPTION; -- Operaciones Constructoras no Generadoras GENERIC WITH FUNCTION Relacion(e1, e2: TipoElemento) RETURN Boolean; PROCEDURE Transforma(lista: IN OUT TipoLista); -- POST: Devuelve la lista resultado de sustituir los elementos que -- cumplen 'Relacion' con el siguiente, por el resultado de la -- combinación de ambos PROCEDURE CombinaListas(lista1, lista2: IN TipoLista; salida: IN OUT TipoLista); -- PRE: Queda suficiente espacio en el heap para crear la lista 'salida' y -- las dos listas tienen la misma longitud -- POST: 'salida' contiene los elementos resultantes de combinar dos a dos -- el primero de 'lista1' con el último de 'lista2', el segundo de -- 'lista1' con el penúltimo de 'lista2', el tercero con el -- antepenúltimo, y así sucesivamente. -- EXCEPCIONES: 'MemoriaAgotada' (excepción definida en el paquete Listas) -- si la memoria dinámica está llena. -- 'DistintaLongitud' si las listas de entrada son de distinta longitud END Listas.Junio10; (c) (2 puntos) -- IMPLEMENTACIÓN ITERATIVA PROCEDURE Transforma(lista: IN OUT TipoLista) IS c, sig: TipoCursor; c := PrimerCursor(lista); WHILE EsCursorValido(lista,c) LOOP sig := Siguiente(lista,c); IF EsCursorValido(lista,sig) AND THEN Relacion(Elemento(lista,c),Elemento(lista,sig)) THEN Reemplazar(lista,c,Combina(Elemento(lista,c),Elemento(lista,sig))); c := sig; END Transforma; -- IMPLEMENTACIÓN RECURSIVA PROCEDURE Transforma(lista: IN OUT TipoLista) IS e, sig: TipoElemento; IF NOT EsVacia(lista) THEN e := Primero(lista); BorrarElemento(e,lista); IF NOT EsVacia(lista) THEN sig := Primero(lista); IF Relacion(e,sig) THEN e := Combina(e,sig); Transforma(lista); Construir(e,lista); END Transforma; 2

3 (d) (1 punto) PROCEDURE CombinaListas(lista1, lista2: IN TipoLista; salida: IN OUT TipoLista) IS c1,c2: TipoCursor; lista_aux: TipoLista; IF Longitud(lista1) /= Longitud(lista2) THEN RAISE DistintaLongitud; ELSE c1 := PrimerCursor(lista1); c2 := UltimoCursor(lista2); CrearVacia(lista_aux); WHILE EsCursorValido(lista1,c1) LOOP InsertarFinal(lista_aux,Combina(Elemento(lista1,c1), Elemento(lista2,c2))); c1 := Siguiente(lista1,c1); c2 := Anterior(lista2,c2); Copiar(salida,lista_aux); Destruir(lista_aux); END CombinaListas; (e) (0,5 puntos) Al estar la operación implementada de forma recursiva, para estudiar su complejidad hay que plantear la ecuación recurrente asociada con el tiempo de ejecución en función del tamaño de la entrada (en este caso la longitud de la lista de entrada, que denotaremos n). Para ello hay que tener en cuenta: 1. El caso base (no recursivo) se da cuando n=0, y su coste es constante puesto que en este caso no hay que hacer nada (la lista de entrada, vacía, no se modifica). 2. El caso recursivo: efectúa una única llamada recursiva, con una entrada cuyo tamaño se ha reducido en una unidad (tamaño n-1) puesto que la llamada previa a BorrarElemento elimina un elemento de la lista. la llamada recursiva anterior está acompañada de varias instrucciones cuyo coste es constante (EsVacía, Primero y Construir) ya que las listas están implementadas con acceso directo a ambos extremos y la operación BorrarElemento se utiliza sólo para borrar el primer elemento de la lista. En consecuencia, la ecuación recurrente asociada es: 1 T ( n) = T ( n 1) + 1 si 0 n< 1 si n 1 La ecuación anterior es un ejemplo típico de ecuación recurrente obtenida por sustracción: a = 1 (número de llamadas recursivas que se realizan) b = 1 (n-b es el tamaño del subproblema generado) k = 0 (n k =1 es el coste de las llamadas no recursivas) por lo que su solución (aplicando la fórmula general dada) es O(n k+1 )=O(n), siendo n la longitud de la lista de entrada. (f) (0,5 puntos) PACKAGE ListaNat IS NEW Listas(Natural); FUNCTION Multiplo(e1, e2: Natural) RETURN Boolean IS RETURN e2 MOD e1 = 0; END Multiplo; PACKAGE ListaNatJunio10 IS NEW ListaNat.Junio10(Combina => "+"); PROCEDURE SumaMultiplos IS NEW ListaNatJunio10.Transforma(Relacion => Multiplo); 3

4 Ejercicio 2. (Puntuación total: 2 puntos) (a) ( 1 punto) PROCEDURE Eliminar (cola : IN OUT TipoCola) IS cursor: ListaElementos.TipoCursor := ListaElementos.UltimoCursor(cola.almacen); ListaElementos.Eliminar(cola.almacen, cursor); -- si cola.almacen está vacío, "cursor" no es válido y ListaElementos.Eliminar -- generará excepción ListaElementos.CursorNoValido: EXCEPTION WHEN ListaElementos.CursorNoValido => Ada.Exceptions.Raise_Exception (ColaVacia'identity, MSG_VACIA); END Eliminar; (b) ( 1 punto) La complejidad de la operación anterior será el máximo de las complejidades de las instrucciones que la componen, es decir, el máximo de las operaciones UltimoCursor y Eliminar del TAD Listas. En cualquiera de los casos que se plantean la operación UltimoCursor tiene claramente complejidad O(1), puesto que siempre habrá acceso directo al último elemento. En cuanto a la operación Eliminar: Si el TAD Listas estuviese implementado mediante memoria estática de forma que el primer elemento de la lista está siempre situado en la posición uno del vector de almacenamiento, la complejidad de la operación Eliminar sería O(1), puesto que consistiría en restar uno al campo que indica la posición en el vector del último elemento. Si el TAD Listas estuviese implementado mediante memoria dinámica con enlace simple y acceso directo a ambos extremos, la complejidad de la operación Eliminar sería O(n), siendo n el número de elementos de la cola, puesto que para actualizar el puntero al último elemento habría que recorrer toda la lista desde su comienzo. Si el TAD Listas estuviese implementado mediante memoria dinámica con enlace doble y acceso directo a ambos extremos, la complejidad de la operación Eliminar sería O(1), puesto que para actualizar el puntero al último elemento bastaría con usar el enlace anterior del último. Ejercicio 3. (Puntuación total: 2 puntos) (a) Las operaciones constructoras generadoras propuestas NO son libres, puesto que pueden generar términos sintácticamente distintos que, sin embargo, representan el mismo valor del tipo de datos. Ejemplos: 1) Los términos Poner(e1, 1, Poner(e2, 1, CrearBolsaVacía)) y Poner(e2, 1, Poner(e1, 1, CrearBolsaVacía)), a pesar de ser distintos, representan la misma bolsa, {e1,e2}. 2) Los términos Poner(e1, 3, CrearBolsaVacía) y Poner(e1, 2, Poner(e1,1,CrearBolsaVacía)) son también distintos pero ambos representan la bolsa {e1, e1, e1}. Las ecuaciones entre generadoras necesarias son, debido a lo anterior, las siguientes: 1) Poner(e1, n1, Poner(e2,n2, bolsa)) = Poner(e2, n2, Poner(e1,n1, bolsa)) (conmutatividad) 2) Poner(e1, n1, Poner(e1, n2, bolsa)) = Poner (e1, n1 + n2, bolsa) (b) (b1) 4

5 Al ser TipoElemento un tipo discreto, éste se puede utilizar como base para los índices de un vector de naturales, con lo que una bolsa de elementos pertenecientes a TipoElemento se puede representar mediante un vector en el que: - las posiciones se corresponden con los valores de TipoElemento; - en cada posición se almacena un número natural que indica el número de ocurrencias en la bolsa del elemento correspondiente. En Ada95: TYPE TipoBolsa IS ARRAY(TipoElemento) OF Natural; Con esta implementación la complejidad de la operación Ocurrencias es evidentemente O(1), puesto que basta con acceder a la posición correspondiente del vector. Con cualquier otra implementación (por ejemplo, listas ordenadas de pares <elemento, num. ocurrencias>) la complejidad de Ocurrencias no podría ser O(1), puesto que habría que buscar el elemento en cuestión dentro de la bolsa. (b2) FUNCTION MismosElementos (bolsa1, bolsa2: TipoBolsa) RETURN Boolean IS cont: TipoElemento := TipoElemento'first; WHILE (Ocurrencias(cont, bolsa1)=0 AND Ocurrencias(cont, bolsa2)=0) OR (Ocurrencias(cont, bolsa1)/=0 AND Ocurrencias(cont, bolsa2)/=0) LOOP cont := TipoElemento'Succ(cont); -- si el bucle termina será porque se ha encontrado un elemento que está en -- una bolsa y no en la otra, y por lo tanto hay que devolver falso. RETURN false; -- en caso contrario se llega a la última posición, y la operación -- "Succ" sobre ella producirá la excepción ConstraintError. EXCEPTION WHEN Constraint_Error => RETURN true; END MismosElementos; La complejidad de la operación MismosElementos en el peor caso es O(p), siendo p el cardinal de TipoElemento, puesto que en el peor caso será necesario recorrer todos los valores de TipoElemento comprobando que en ambas bolsas el número de ocurrencias del elemento es o bien cero o bien distinto de cero (el bucle WHILE se repite en el peor caso p veces, teniendo su cuerpo coste constante). 5