¡Descarga Ingeniería Telemática 05 2016 y más Exámenes en PDF de Ingeniería Telemática solo en Docsity!
Leganés, 6 de mayo de 2016 Examen parcial 2 (problemas)
Duración de la prueba: 80 min Puntuación: 7 puntos sobre 10 del examen
Instrucciones:
● Resuelve cada problema en una hoja separada.
● No olvides escribir tu nombre en cada hoja de papel que entregues.
● No se permiten libros ni apuntes.
Problema 1 (3,5 puntos)
Se quiere programar la estructura de datos de una aplicación de dibujo en 2D. La aplicación va a
manejar figuras (modeladas con la clase Figure), que están formadas por puntos (clase Point),
cuya implementación se muestra a continuación.
public class Point { public double x; public double y; public Point(double x, double y) { this.x = x; this.y = y; } public String toString() { return "(" + x + ", " + y + ")"; } }
La figura almacena la serie de puntos en una lista enlazada e incluye funcionalidad para añadir
puntos en diferentes posiciones, así como imprimir la información.
public class Figure { // atributos private String name; private Node first; private Node last; private int points; // constantes public static final int BEGIN = 0; public static final int END = - 1; // constructor public Figure(String name) { this.name = name; first = null; last = null; points = 0; }
// método para añadir puntos public void addPoint(Point p, int position) throws FigureException { // apartado 2 } // method to return the info public String toString() { // apartado 3 (puede dividirse en dos métodos) } }
La clase auxiliar Node necesaria para implementar la lista enlazada se muestra a continuación.
public class Node { public E info; public Node next; public Node(E info, Node next) { this.info = info; this.next = next; } }
Apartado 1 (0, 5 puntos)
Implementa la clase FigureException, con la estructura habitual de las excepciones.
Apartado 2 ( 1 ,5 puntos)
Implementa el método:
public void addPoint(Point p, int position)
que añade el punto p en la posición especificada de la lista de puntos almacenados: al principio
(valor 0), al final (valor - 1), o en una posición intermedia (pasando cualquier valor entero; por
ejemplo, un 1 indica que el punto se añade como segundo elemento de la lista, entre el primero y el
tercero).
Para facilitar la codificación, utiliza las constantes BEGIN y END, para representar la posición inicial
y final en la lista de puntos.
Si la posición no es válida o no se puede insertar el punto, se debe lanzar una excepción con el
mensaje correspondiente.
Apartado 3 ( 1 ,5 puntos)
Implementa el método toString() que imprime la lista de puntos, con el siguiente formato:
[nº de puntos]: (x1, y1) (x2, y2) … (xn, yn)
La implementación debe ser recursiva. Como idea, divide el método toString en dos: primero
imprime el nombre de la figura y el número de puntos, y luego imprime los puntos llamando a un
método auxiliar recursivo, basado en la siguiente lógica: “para imprimir una lista de puntos, imprimo
el primer punto, y luego imprimo la lista restante”.
Apartado 2 (1,5 puntos)
Implementa el método:
String toStringMenorAMayor()
que devuelve una cadena con la información de los elementos en una ordenación de menor a mayor.
Apartado 3 (1 punto)
Implementa el método:
BSTree search(Comparable key)
que permitirá buscar por una clave dada.
Apartado 4 (0,5 puntos)
Implemente un gestor de empleados, utilizando la clase LBSTree y sabiendo que el
criterio de ordenación se hace mediante el DNI. Se deberán poder insertar y buscar empleados
además de mostrarlos por pantalla de menor a mayor (según DNI).
Nota: No se considera el uso de excepciones.
Soluciones
Problema 1 (3,5 puntos)
Apartado 1 ( 0 , 5 puntos)
public class FigureException extends Exception { public FigureException(String message) { super(message); } } Criterios de corrección: (0, 5 ) Si extiende de Exception, tiene el constructor con un mensaje y llama a super. 0 en caso contrario.
Apartado 2 (1,5 puntos)
public void addPoint(Point p, int position) throws FigureException { Node node = new Node(p, null); // al principio if(position==BEGIN) { node.next = first; first = node; if(last==null) { last = first; } // al final } else if(position==END) { if(last==null) { first = node; last = first; } else { last.next = node; last = node; } // en posición intermedia } else { Node current = first; int pos = 0; while(current!=null && pos+1<position) { pos++; current = current.next; } if(current!=null) { node.next = current.next; current.next = node; } else { throw new FigureException("Wrong position"); } } points ++; } Criterios de corrección: (+0,5) Inserción al principio correcta (+0,4) Inserción al final correcta (+0, 6 ) Inserción intermedia correcta
public boolean isEmpty() { return (this.root == null); } public E getInfo() { if (!this.isEmpty()) { return this.root.getInfo(); } return null; } public Comparable getKey() { if (!this.isEmpty()) { return this.root.getKey(); } return null; } public BSTree getLeft() { if (!this.isEmpty()) { return this.root.getLeft(); } return null; } public BSTree getRight() { if (!this.isEmpty()) { return this.root.getRight(); } return null; }
// lo hemos llamado en enunciado: toStringMenorAMayor
public String toStringInOrder() { String treeStr = ""; if(!this.isEmpty()) { // Izquierda if(!this.getLeft().isEmpty()) { treeStr = treeStr + this.getLeft().toStringInOrder(); } // Raíz treeStr = treeStr + this.getInfo().toString() + "\n"; // Derecha if(!this.getRight().isEmpty()) { treeStr = treeStr + this.getRight().toStringInOrder(); } } return treeStr; } public void insert(Comparable key, E info) { if(this.isEmpty()) {
this.root = new LBSNode(key,info,new LBSTree(), new LBSTree()); } else { if (this.root.getKey().compareTo(key) > 0) { // lower key - > insert in the left subtree this.getLeft().insert(key,info); } else if (this.root.getKey().compareTo(key) < 0) { // greater key - > insert in right subtree this.getRight().insert(key,info); } else { this.root.setInfo(info); } } } public BSTree search(Comparable key) { BSTree searchedSubtree = null; if(!this.isEmpty()) { if(this.root.getKey().compareTo(key) > 0) { // lower key - > search in the left subtree searchedSubtree = this.getLeft().search(key); } else if (this.root.getKey().compareTo(key) < 0) { // greater key - > insert in the right subtree searchedSubtree = this.getRight().search(key); } else { // equal keys searchedSubtree = this; } } //if reaching an empty subtree - > key not found // Puede que no lo encontremos. return searchedSubtree; } } public class Empleados { private LBSTree empleados; public Empleados() { empleados = new LBSTree(); } public void insert(Long dni, Empleado e) { empleados.insert(dni, e); }
