Escuela Superior de Informatica AplicadaCorreccion del Primer Parcial de Estructuras de Datos y Algoritmos (16-Junio-2003)

1. (4 puntos) Dado un vector de numeros enteros, v, ordenados ascendentemente y sin elementos repetidos, se desea obtenerla posicion i en el vector tal que v[i] = i; en el caso que no haya ninguna posicion para la que se cumpla dicha condicion elresultado sera 1. Se pide:a) disenar un metodo recursivo de coste mnimo que resuelva este problema. (2 puntos)

public static int buscar (int []v, int inf, int sup){int med=0;// caso base, no se ha encontrado el elementoif (inf > sup) return -1;else{

med=(inf+sup)/2;if (med==v[med]) return med;else

if ( med < v[med] )// solo es posible que este en la parte izquierda

return buscar.(v,inf,med-1);else return buscar (v, med+1, sup);

}}

Siendo la llamada inicial:

buscar(v,0,v.length)

b) estudiar la complejidad temporal de la solucion propuesta, planteando las ecuaciones de recurrencia que expresan lafuncion de coste y resolviendolas por sustitucion. (1 punto)

La funcion de coste T (n) la plantearemos en funcion del tamano del problema, que es el numero de elementos delvector n=v.length. Para un tamano fijo, podemos senalar las siguientes instancias significativas:

caso mejor: el elemento central cumple la propiedad y el coste es O(1)caso peor: No hay ningun elemento del vector que cumpla la propiedad. En este caso, las ecuaciones de recurrenciason: (n > 1): T (n) = T (n/2) + k (n = 1): T (n) = k

Resolucion por sustitucion: hasta que el argumento se hace uno hay que dividir m veces por 2 y acumular m vecesk:

T (n) = T (n/2) + k = T (n/2) + 2k = ... = T (n/2m) + mk = ... = T (1) + klogn (logn)

c) En el caso que el vector tuviera elementos repetidos cual sera el coste del metodo mas eficiente que resuelve el mismoproblema?. Por que?. (1 punto)

En el caso que el vector tenga elementos repetidos la busqueda de la propiedad no se puede plantear como una busquedadicotomica y por lo tanto su coste se corresponde con el de una busqueda normal que en el peor de los casos es O(n).

1

2. (2.5 puntos) Las clases siguientes implementan una jerarqua de herencia.

class Base{String metodo1() { return "Base.metodo1()";}String metodo2(String s) {return "Base.metodo2(" + s + ")";}

}public interface TipoI{

String metodoIn2(String s);String metodoIn3();

}class Derivada extends Base implements TipoI{

public String metodoIn2(String s) {return "Derivada.metodoIn2()";}public String metodoIn3() {return "Derivada.metodoIn3()";}String metodo1() { return "Derivada.metodo1()";}

}class Derivada2 extends Derivada{

String metodo2(String s) {return "Derivada2.metodo2("+s+")";}String metodo4() { return "Derivada2.metodo4()";}

}

Sea la clase CuestionHerencia que usa las anteriores.

public class CuestionHerencia{public static void main(String a[]){

String tmp;Derivada derivada;Derivada2 derivada2;Base base;derivada2= new Derivada2(); base=derivada2;tmp= derivada2.metodo1(); System.out.println("1.-"+ tmp);tmp= derivada2.metodoIn2("EDA!!"); System.out.println("2.-"+ tmp);tmp= base.metodo1(); System.out.println("3.-"+ tmp);tmp= base.metodo2("EDA!!"); System.out.println("4.-"+ tmp);tmp= derivada2.metodoIn3(); System.out.println("5.-"+ tmp);tmp= derivada2.metodo4(); System.out.println("6.-"+ tmp);tmp= base.metodo3(); System.out.println("7.-"+ tmp);derivada= new Derivada();derivada2= new Derivada2();base= new Base();Distinta ref= new Distinta();tmp= ref.prueba(derivada2); System.out.println("8.-"+ tmp);tmp= ref.prueba(derivada); System.out.println("9.-"+ tmp);tmp= ref.prueba(base); System.out.println("10.-"+ tmp);

}}

2

Se pide:

a) si existen, senalar los errores de compilacion;

La clase Distinta no esta definida. Por lo tanto se eliminan las ultimas 4 lneas que hacen referencia al objeto ref.El siguiente error se produce al compilar tmp= base.metodo3(), ya que metodo3 no es un metodo de la clase Base.Por lo tanto se elimina esta asignacion y el posterior System.out.println("7.-"+ tmp);

b) una vez corregido el programa, escribir la salida por pantalla resultado de su ejecucion del programa.

1.-Derivada.metodo1()2.-Derivada.metodoIn2()3.-Derivada.metodo1()4.-Derivada2.metodo2(EDA!!)5.-Derivada.metodoIn3()6.-Derivada.metodo4()

3. (3.5 puntos) Se ha disenado el siguiente interfaz Java:

import Excepciones.*;public interface Secuencia {

Comparable buscar(Comparable x) throws ElementoNoEncontrado;Comparable buscarMin() throws ElementoNoEncontrado;Comparable buscarMax() throws ElementoNoEncontrado;void eliminarMin()throws ElementoNoEncontrado;Comparable eliminar(Comparable x) throws ElementoNoEncontrado;void insertar (Comparable x) throws ElementoDuplicado;boolean esvacio();

}

Se dispone tambien de las clases NodoLista, ElementoNoEncontrado y ElementoDuplicado, cuyos contenidos son, respecti-vamente:

public class NodoLista {Comparable dato;NodoLista sig;public NodoLista(Comparable x){dato = x; sig = null;}public NodoLista(Comparable x, NodoLista siguiente){dato = x; sig = siguiente;}

}public class ElementoNoEncontrado extends Exception {

public ElementoNoEncontrado(String mensajeError){super(mensajeError);}}public class ElementoDuplicado extends Exception {

public ElementoDuplicado(String mensajeError){super(mensajeError);}}

A partir de estas clases se quiere disenar la clase SecuenciaOrdenada, que implementa el interfaz Secuencia utilizando unarepresentacion enlazada de elementos ordenados. En particular, el atributo y constructora vaca de dicha clase son:

3

// AtributoNodoLista primero;// Metodo constructorpublic SecuenciaOrdenada(){primero= new NodoLista(null);

}

Se pide:

a) (2 puntos) implementar el metodo eliminar en SecuenciaOrdenada;

public class SecuenciaOrdenada implements Secuencia {NodoLista primero;public SecuenciaOrdenada(){

primero=new NodoLista(null);}public Comparable eliminar(Comparable x) throws ElementoNoEncontrado{

NodoLista q=primero.sig, qant=primero;while (q!=null && q.dato.compareTo(x)0)

throw new ElementoNoEncontrado("el elemento no pertenece a la secuencia");qant.sig=q.sig;return q.dato;

}

}

b) (1 punto) definir la talla del problema y calcular la complejidad del metodo eliminar;

talla del problema: numero de elementos de la secuencia ordenada (n)caso mejor: el elemento x es el primero de la secuencia (ordenada). En este caso el coste es constante con la talladel problemacaso peor: el elemento x es mayor que el ultimo de la secuencia (ordenada) y el coste es lineal con la talla delproblema

c) (0.5 puntos) en la clase SecuenciaOrdenada que modificaciones permitiran simplificar el codigo de eliminar?.

Ninguna, puesto que la secuencia ordenada ya tiene un elemento ficticio

4