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

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

Resolución Prácticas (Segunda Parte) - Junio 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 class Celda {

private String paciente;
private Celda sig;

}
private Celda[] frente,post;
private String medico[], especialidad[];
public Consultorio(int n, String[] med, String[] esp) throws ConsultorioException {

if (n<=0) throw new ConsultorioException("El número de consultas debe ser mayor que cero");
if (med.length!=n) throw new ConsultorioException("Tamaño de med incorrecto");
if (esp.length!=n) throw new ConsultorioException("Tamaño de esp incorrecto");
frente = new Celda[n];
post = new Celda[n];
medico = new String[n];
especialidad = new String[n];
for(int i=0;i<n;i++) { frente[i] = new Celda();

post[i] = frente[i];
medico[i] = med[i];
especialidad[i] = esp[i]; } }

public String medico(int i) throws ConsultorioException {

if ((i<1)||(i>frente.length)) throw new ConsultorioException("Índice de consulta incorrecto");
if (i>frente.length) throw new ConsultorioException("i mayor que "+frente.length);
return medico[i-1]; }

public String especialidad(int i) throws ConsultorioException {

if ((i<1)||(i>frente.length)) throw new ConsultorioException("Índice de consulta incorrecto");
return especialidad[i-1]; }

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

if ((i<1)||(i>frente.length)) throw new ConsultorioException("Índice de consulta incorrecto");
post[i-1].sig = new Celda();
post[i-1] = post[i-1].sig;
post[i-1].paciente = p; }

public void suprimePaciente(int i) throws ConsultorioException {

if ((i<1)||(i>frente.length)) throw new ConsultorioException("Índice de consulta incorrecto");
if (frente[i-1]==post[i-1]) throw new ConsultorioException("La consulta "+i+" está vacía.");
frente[i-1]=frente[i-1].sig; }

public String primerPaciente(int i) throws ConsultorioException {

if ((i<1)||(i>frente.length)) throw new ConsultorioException("Índice de consulta incorrecto");
if (frente[i-1]==post[i-1]) throw new ConsultorioException("La consulta "+i+" está vacía.");
return frente[i-1].sig.paciente; }

public boolean vacia(int i) throws ConsultorioException {

if ((i<1)||(i>frente.length)) throw new