PDF de programación - metodología y Tecnología de la Programación - prácticas - segunda parte

Metodología y Tecnología de la Programación

Resolución Prácticas (Segunda Parte) - Septiembre 2008

1

import java.io.*;
public class UtilVector {

/**

* Lee un vector de objetos de la clase Elemento.
* @param n El número de elementos del vector que se va a leer.
* @throws IOException Si ocurre una excepción de entrada/salida.
* @throws NumberFormatException Si el formato de algún entero no es correcto.
* @return Un vector de objetos de la clase Elemento que contiene
*
*/

los elementos leídos del teclado.

static public Elemento[] leeElemento(int n) throws IOException, NumberFormatException {

Elemento[] e = new Elemento[n];
for(int i=0;i<n;i++) e[i] = new Elemento(Util.leeEntero());
return e;

}
/**

* Lee un vector de objetos de la clase Integer.
* @param n El número de elementos del vector que se va a leer.
* @throws IOException Si ocurre una excepción de entrada/salida.
* @throws NumberFormatException Si el formato de algún entero no es correcto.
* @return Un vector de Integer que contiene los elementos leídos del teclado.
*/

static public Integer[] leeInteger(int n) throws IOException, NumberFormatException {

Integer[] e = new Integer[n];
for(int i=0;i<n;i++) e[i] = new Integer(Util.leeEntero());
return e;

}
/**

* Imprime por pantalla un vector de objetos genéricos.
* @param e El vector de objetos genéricos que se va a imprimir.
*/

static public void imprime(Object[] e) {

for(int i=0;i<e.length;i++) System.out.print(e[i]+" ");
System.out.println();

}
/**

* Ordena crecientemente los elementos del vector e.
* @param e El vector de elementos comparables que se va a ordenar.
*/

static public void ordena(Comparable[] e) {

for(int i=0;i<e.length-1;i++)

for(int j=i+1;j<e.length;j++)

if (e[j].compareTo(e[i])<0) { Comparable aux = e[j]; e[j] = e[i]; e[i] = aux; }

}
static public void main(String args[]) {

try {

Elemento[] e = leeElemento(5);
imprime(e);
ordena(e);
imprime(e);
Integer[] i = leeInteger(5);
imprime(i);
ordena(i);
imprime(i);

} catch (IOException e)
} catch (NumberFormatException e) { System.err.println(e); }

{ System.err.println(e);

}

} // fin class UtilVector

Figura 1: Clase para la utilización de vectores de objetos de las clases Elemento e Integer.

2

public class ConjuntoContiguo implements ConjuntoInterface {

private Comparable[] elem;
private int n;
public ConjuntoContiguo() { n=0; }
public ConjuntoContiguo(ConjuntoContiguo c, Comparable e) throws ConjuntoException {

n = c.n+1;
elem = new Comparable[n];
int i=n-1;
while((i>0)&&(e.compareTo(c.elem[i-1])<0)) {

elem[i] = c.elem[i-1];
i--;

}
if ((i>0)&&(e.compareTo(c.elem[i-1])==0))

throw new ConjuntoException("El elemento "+e+" ya se encuentra en el conjunto "+c);

elem[i] = e;
i--;
while(i>=0) {

elem[i] = c.elem[i];
i--;

}

}
public boolean vacio() {

return (n==0);

}
public boolean pertenece(Comparable e) {

int i=n-1;
while(e.compareTo(elem[i])<0) i--;
return (e.compareTo(elem[i])==0);

}
public ConjuntoInterface suprimeMaximo() throws ConjuntoException {

if (n==0)

throw new ConjuntoException("No se puede devolver el máximo de un conjunto vacío");

ConjuntoContiguo aux = new ConjuntoContiguo();
aux.n = n-1;
aux.elem = elem;
return aux;

}
public Comparable maximo() throws ConjuntoException {

if (n==0)

throw new ConjuntoException("No se puede devolver el máximo de un conjunto vacío");

return elem[n-1];

}
public String toString() {

String s = "";
for(int i=0;i<n;i++) s+=elem[i]+" ";
return s;

}

} // fin class ConjuntoContiguo

Figura 2: Implementación Robusta del TDA Conjunto Parcialmente Genérico con Representación Contigua.

3

public class ConjuntoEnlazado implements ConjuntoInterface {

private ConjuntoEnlazado sig;
private Comparable elem;
public ConjuntoEnlazado() {

sig=null;

}
public ConjuntoEnlazado(ConjuntoEnlazado c, Comparable e) throws ConjuntoException {

if ((c.sig==null)||(e.compareTo(c.elem)>0)) {

sig=c;
elem=e;

} else if (e.compareTo(c.elem)<0){

sig = new ConjuntoEnlazado(c.sig,e);
elem = c.elem;

}
else

throw new ConjuntoException("El elemento "+e+" ya se encuentra en el conjunto "+c);

}
public boolean vacio() {

return (sig==null);

}
public boolean pertenece(Comparable e) {

if ((sig==null)||(e.compareTo(elem)>0)) return false;
if (e.compareTo(elem)<0) return sig.pertenece(e);
return true;

}
public ConjuntoEnlazado suprimeMaximo() throws ConjuntoException {

if (sig==null)

throw new ConjuntoException("No se puede suprimir el máximo de un conjunto vacío");

return sig;

}
public Comparable maximo() throws ConjuntoException {

if (sig==null)

throw new ConjuntoException("No se puede devolver el máximo de un conjunto vacío");

return elem;

}
public String toString() {

if (sig==null) return "";
return sig+" "+elem;

}

} // fin clase ConjuntoEnlazado

Figura 3: Implementación Robusta del TDA Conjunto Parcialmente Genérico con Representación Enlazada.

public interface ConjuntoInterface {

public boolean vacio();
public boolean pertenece(Comparable e);
public ConjuntoInterface suprimeMaximo() throws ConjuntoException;
public Comparable maximo() throws ConjuntoException;

}

Figura 4: Interface del TDA Conjunto Parcialmente Genérico.

4

import java.io.*;
public class UtilConjunto{

static private void imprimeOrdenado(ConjuntoInterface c) {

// Imprime en pantalla los elementos del conjunto c ordenados decrecientemente.
try { while(!c.vacio()) { System.out.print(c.maximo()+" ");

System.out.println();

} catch(ConjuntoException e) { System.err.println(e); }

c = c.suprimeMaximo(); }

}
static public void main(String args[]) {

try {
// Construye un conjunto de la clase ConjuntoContiguo de objetos de la clase {\tt Elemento}.
// Imprime el conjunto ordenado crecientemente mediante el método toString del conjunto.
// Imprime el conjunto ordenado decrecientemente mediante el método imprimeOrdenado.
ConjuntoContiguo cc = new ConjuntoContiguo();
for(int i=0;i<5;i++) {

System.out.print("Elemento "+i+": ");
cc = new ConjuntoContiguo(cc,new Elemento(Util.leeEntero()));

}
System.out.println(cc);
imprimeOrdenado(cc);
// Construye un conjunto de la clase ConjuntoContiguo de objetos de la clase {\tt Integer}.
// Imprime el conjunto ordenado crecientemente mediante el método toString del conjunto.
// Imprime el conjunto ordenado decrecientemente mediante el método imprimeOrdenado.
cc = new ConjuntoContiguo();
for(int i=0;i<5;i++) {

System.out.print("Integer "+i+": ");
cc = new ConjuntoContiguo(cc,new Integer(Util.leeEntero()));

}
System.out.println(cc);
imprimeOrdenado(cc);
// Construye un conjunto de la clase ConjuntoEnlazado de objetos de la clase {\tt Elemento}.
// Imprime el conjunto ordenado crecientemente mediante el método toString del conjunto.
// Imprime el conjunto ordenado decrecientemente mediante el método imprimeOrdenado.
ConjuntoEnlazado ce = new ConjuntoEnlazado();
for(int i=0;i<5;i++) {

System.out.print("Elemento "+i+": ");
ce = new ConjuntoEnlazado(ce,new Elemento(Util.leeEntero()));

}
System.out.println(ce);
imprimeOrdenado(ce);
// Construye un conjunto de la clase ConjuntoEnlazado de objetos de la clase {\tt Integer}.
// Imprime el conjunto ordenado crecientemente mediante el método toString del conjunto.
// Imprime el conjunto ordenado decrecientemente mediante el método imprimeOrdenado.
ce = new ConjuntoEnlazado();
for(int i=0;i<5;i++) {

System.out.print("Integer "+i+": ");
ce = new ConjuntoEnlazado(ce,new Integer(Util.leeEntero()));

}
System.out.println(ce);
imprimeOrdenado(ce);
} catch(NumberFormatException e) { System.err.println(e);
} catch(ConjuntoException e)
{ System.err.println(e);
{ System.err.println(e); }
} catch (IOException e)

}

} // fin class UtilConjunto

Figura 5: Clase para la utilización de objetos que
implementen la interface
ConjuntoInterface. Particularmente, utilizará objetos de las clases ConjuntoContiguo y
ConjuntoEnlazado.

5

public class Consultorio {

private int nconsultas,max;
private String[][] pacientes;
private int[] frente, post;
private int[] npacientes;
private String[] medico, especialidad;
public Consultorio(int n, int m, String[] medicos, String[] especialidades) throws ConsultorioException {

if (n<=0) throw new ConsultorioException("El número de consultas debe ser mayor que cero");
if (m<=0) throw new ConsultorioException("El número máximo de pacientes debe ser mayor que cero");
if ((medicos.length!=n)||(especialidades.length!=n)) throw new ConsultorioException("El tamaño de los arrays de médicos y especialidades no coincide con el número de consultas");
nconsultas=n;
max = m;
pacientes = new String[n][max];
frente = new int[n];
post = new int[n];
npacientes = new int[n];
medico = medicos;
especialidad = especialidades;
for(int i=0;i<n;i++) {

frente[i] = 1;
post[i] = 0;
npacientes[i] = 0; } }

public String medico(int i) throws ConsultorioException {

if ((i<1)||(i>nconsultas)) throw new ConsultorioException("El índice de consulta debe estar entre 1 y "+nconsultas);
return medico[i-1]; }

public String especialidad(int i) throws ConsultorioException {

if ((i<1)||(i>nconsultas)) throw new ConsultorioException("El índice de consulta debe estar entre 1 y "+nconsultas);
return especialidad[i-1]; }

public void insertaPaciente(int i, String p) throws ConsultorioException {

if ((i<1)||(i>nconsultas)) throw new ConsultorioException("El índice de consulta debe estar entre 1 y "+nconsultas);
if (npacientes[i-1]==max) throw new ConsultorioException("El número de pacientes ya es el maximo");
post[i-1] = (post[i-1]+1)%max;
pacientes[i-1][post[i-1]]=p;
npacientes[i-1]++; }

public void suprimePaciente(int i) throws ConsultorioException {

if ((i<1)||(i>nconsultas)) throw new ConsultorioException("El índice de consulta debe estar entre 1 y "+nconsultas);
if (npacientes[i-1]==0) throw new ConsultorioException("La consulta "+i+" está vacía: no se puede suprimir un paciente.");
frente[i-1] = (frente[i-1]+1)%max;
npacientes[i-1]--; }

public String primerPaciente(int i) throws Co