1. 3.51.-Diseñe y especifique formalmente el TAD Bicola. Piense en la posibilidad de tener una
ventana sobre el extremo en el que se van a realizar las operaciones.
TAD Bicola[TipoBC]
X1 X2 X3 ….. Xn
{ invariante: TRUE }
Constructoras:
inicBiCola()
Modificadoras:
insertFirst()
insertLast()
removeFirst()
removeLast()
Analizadoras:
infoBiColaFrente()
infoBiColaFinal()
vaciaBiCola()
----------------------------------------------------------------------
inicBiCola()
/* Crea una Bicola vacía */
{ post: inicBiCola = Ø }
----------------------------------------------------------------------
void adicBiColaFrente(T elem )
/* Agrega el elemento elem al frente de la cola */
{ post: bicola = elem,x1,x2,…,xn }
----------------------------------------------------------------------
void adicBiColaFinal(T elem )
/* Agrega el elemento elem al final de la cola */
{ post: bicola = x1,x2,…,xn, elem }
----------------------------------------------------------------------
void elimBiColaFrente()
/* Elimina el elemento que está al frente de la bicola */
{ pre: n > 0 }
{ post: bicola = x2,…,xn }
----------------------------------------------------------------------
void elimBiColaFinal()
/* Elimina el elemento que está al final de la bicola */
{ pre: n > 0 }
{ post: bicol = x1,x2,…,xn-1 }
----------------------------------------------------------------------
T infoBiColaFrente()
/* Retorna el elemento que está al frente de la bicola */

2. { pre: n > 0 }
{ post: infoBiColaFrente = x1 }
----------------------------------------------------------------------
T infoBiColaFinal()
/* Retorna el elemento que está al final de la bicola */
{ pre: n > 0 }
{ post: infoBiColaFinal = xn }
----------------------------------------------------------------------
bool vaciaBiCola()
/* Informa si la bicola está vacía */
{ post: vaciaBiCola = ( bicol = ) }
----------------------------------------------------------------------
void destruirBiCola()
/* Destruye la bicola retornando toda la memoria ocupada */
{ post: la bicola ha sido destruida }
3.52
3.53
//Nodo.java
public class Nodo {
private Object o;
private Nodo next;
private Nodo back;
public Nodo (){
o=null;
next=null;
back=null;
}
public Nodo(Object o, Nodo next,Nodo back){
this.o=o;
this.next=next;
this.back=back;
}
public void setValor(Object z){
o=z;

3. }
public Object getValor(){
return o;
}
public Nodo getNext(){
return next;
}
public void setNext(Nodo next){
this.next=next;
}
public Nodo getBack(){
return back;
}
public void setBack(Nodo back){
this.back= back;
}
}
// Bicola.java
public class Bicola {
Nodo head, tail;
int size;
public void inicBicola()
{
head = new Nodo();
tail = new Nodo();
head.setNext(tail);
tail.setBack(head);
size=0;
}
public void insertFirst(Object obj) {
Nodo h = head;
Nodo node = new Nodo();
node.setValor(obj);
node.setNext(h);
h.setBack(node);
head = node;
if (size == 0)
tail = node;
size++;
}
public void insertLast(Object obj) {
Nodo t = tail;
Nodo node = new Nodo();

4. node.setValor(obj);
node.setBack(t);
t.setNext(node);
tail = node;
if (size == 0)
head = node;
size++;
}
public Object removeFirst() {
if (head == null)
return null;
Object val = head.getValor();
head = head.getNext();
size--;
return val;
}
public Object removeLast() {
if (tail == null)
return null;
Object val = tail.getValor();
tail = tail.getBack();
size--;
return val;
}
public int size() {
return size;
}
public Object infoBicolaFirst()
{
return head.getValor();
}
public Object infoBicolaLast()
{
return tail.getValor();
}
public boolean vaciaBicola()
{
return size==0?true:false;
}
public String toString() {
String s = "head [";
Nodo aux = head;
for (int i = 0; i < size; i++) {
s += aux.getValor();
if (aux == tail) {
break;
}
s += "-";
aux = aux.getNext();
}

5. return s + "] tail";
}
}
//Demo Bicola
public class DemoBicolas {
public static void main(String[]args)
{
Bicola bicola1=new Bicola();
bicola1.inicBicola();
bicola1.insertFirst(45);
bicola1.insertLast(4);
bicola1.insertFirst(11);
bicola1.insertFirst(22);
bicola1.insertFirst(33);
bicola1.insertFirst(5);
bicola1.insertFirst(1);
System.out.println(bicola1.toString());
System.out.println(bicola1.size());
bicola1.removeFirst();
System.out.println(bicola1.toString());
bicola1.removeLast();
System.out.println(bicola1.toString());
}
}
3.54
3.55
import java.io.*;
import java.util.*;
/**
* Clase para introducir datos de un fichero de texto con enteros a una tabla de
frecuencias.

6. */
public class Estadisticas
{
public static void main(String[] args) {
Tabla t = new Tabla();
t.aniadir(1);
// System.out.print(t.getInfoEnt(1));
t.aniadir(2);
t.aniadir(3);
t.aniadir(4);
t.aniadir(1);
t.aniadir(2);
System.out.print(t.getInfoEnt(1));
}
}
/**
* Clase para representar frecuencias de enteros.
*
* @author
* @version
*/
class Frecuencia
{
private int numero;
private int frecuencia;
/**
* Construye una frecuencia
*/
public Frecuencia(int numero, int frecuencia)
{

7. this.numero = numero;
this.frecuencia = frecuencia;
}
/**
* Método observador del entero
*/
public int getNumero()
{
return numero;
}
/**
* Método observador de la frecuencia;
*/
public int getFrecuencia()
{
return frecuencia;
}
/**
* Suma uno a la frecuencia
*/
public void sumar1()
{
frecuencia++;
}
}
public class Tabla
{
private static final int MAX_NUM_DATOS = 1000;
private Frecuencia[] tabla;
private int total;
/**
* Construye una tabla de frecuencias vacía.
*/
public Tabla()
{
tabla = new Frecuencia[MAX_NUM_DATOS];
inicializar();
}
/**
* Vacía la tabla de frecuencias.

8. */
public void inicializar()
{
total = 0;
}
/**
* Incrementa en uno la frecuencia de un entero de la tabla.
* La implementación limita a MAX_NUM_DATOS el número de datos distintos.
* Si no cabe en la tabla, devuelve error=cierto
* @param n entero a mofificar la frecuencia en uno.
* @return cierto si no cabe en la tabla. Falso, en caso contrario.
*/
public boolean aniadir(int n)
{
//encontrar n en tabla
int pos = buscar(n);
System.out.println(pos);
return true;}
/* boolean error = false;
//si está n en tabla, recolocar
if (pos != -1) {
tabla[pos].sumar1();
while (pos > 0 && tabla[pos].getNumero() > tabla[pos-1].getNumero())
{
Frecuencia aux = tabla[pos];
tabla[pos] = tabla[pos-1];
tabla[pos-1] = aux;
pos--;
}
} else { //si no esá, introducir al final si se puede
if (getTotal() < tabla.length) {
total++;
tabla[getTotal()] = new Frecuencia(n, 1);
} else {
error = true;
}
}
return error;
}*/
/**
* Retorna el número de enteros distintos de la tabla.
* @return enteros distintos de la tabla.
*/
public int getTotal()
{
return total;
}
/**
* Retorna la frecuencia i-ésima ordenada de mayor a menor
* @param i posición i-ésima

9. * @return frecuencia i-ésima ordenada de mayor a menor. Si no exite la
posición i-ésima
* se retorna la frecuencia (0,0)
*/
public Frecuencia info(int i)
{
if (0 <= i && i < getTotal()) {
return new Frecuencia(getInfoEnt(i), getInfoFrec(i));
} else {
return new Frecuencia(0, 0);
}
}
/**
* Retorna el entero i-ésimo ordenado de mayor a menor de la tabla de
frecuencias.
* @param i posición i-ésima de la tabla
* @return entero en la posición i-ésima. Si no existe la posición i-ésima,
retorna 0
*/
public int getInfoEnt(int i)
{
if (i <= 0 && i < getTotal()) {
return tabla[i].getNumero();
} else {
return 0;
}
}
/**
* Retorna el valor de la frecuencia i-ésima ordenada de mayor a menor de la
tabla.
* @param i posición i-ésima
* @return entero con la frecuencia de la posición i-ésima. Si no existe la
posición,
* se retorna 0
*/
public int getInfoFrec(int i)
{
if (i <= 0 && i < getTotal()) {
return tabla[i].getFrecuencia();
} else {
return 0;
}
}
/**
* Retorna la posición dentro de la tabla de un número dado.
* @param n número a buscar
* @return posición dentro de la tabla donde está n. Si no se encuentra,
retorna -1;
*/
private int buscar(int n)
{
int i;

10. for (i = 0; i < getTotal() && getInfoEnt(i) != n; i++);
if (i == getTotal() || getInfoEnt(i) != n) {
i = -1;
}
return i;
}
}
3.56
public class BolsaLista
{
// -----------------------------------------------------------------
// Atributos
// -----------------------------------------------------------------
/**
* Primer elemento que tiene la estructuraBolsa
*/
private Elemento primerElemento;
/**
* Límite inferior de la estructuraBolsa
*/
private int inferior;
/**
* Límite superior de la estructuraBolsa
*/
private int superior;
/**
* Cantidad de elementos que tiene la estructuraBolsa
*/
private int cantidadElementos;
// -----------------------------------------------------------------
// Constructores
// -----------------------------------------------------------------

11. /**
* Método constructor por parámetros
* @param inf Limite inferior
* @param sup Limite superior
*/
public BolsaLista( int inf, int sup )
{
primerElemento = null;
cantidadElementos = 0;
inferior = inf;
superior = sup;
}
// -----------------------------------------------------------------
// Métodos
// -----------------------------------------------------------------
/**
* Agrega un elemento a la estructuraBolsa
* <b>pre:</b> inferior < elem < superior <br>
* <b>post:</b> elem es agregado a la lista encadenada
* @param elem Elemento que se va a agregar a la estructuraBolsa
*/
public void agregar( int elem ) throws FueraLimiteException
{
if( elem > inferior && elem < superior )
{
Elemento nodo = new Elemento( elem );
if( primerElemento == null )
primerElemento = nodo;
else if( nodo.obtenerValor( ) < primerElemento.obtenerValor( ) )
{
// Debe quedar como primer elemento de la lista
primerElemento.insertarAntes( nodo );
primerElemento = nodo;
}
else
{
Elemento p = primerElemento;
for( ; p.obtenerSiguiente( ) != null && p.obtenerSiguiente(
).obtenerValor( ) < nodo.obtenerValor( ); p = p.obtenerSiguiente( ) )
;
p.insertarDespues( nodo );
}
cantidadElementos++;
}
else
throw new FueraLimiteException( "Elemento fuera de rango" );
}
/**
* Elimina un elemento de la estructuraBolsa
* <b>pre:</b> Existe un elemento en la lista encadenada tal que su valor es
igual a elem <br>

12. * <b>post:</b> elem es eliminado de la lista encadenada
* @param elem Elemento que va a ser eliminado
* @throws NoExisteException Se lanza la excepción si no se encuentra el
elemento
*/
public void eliminar( int elem ) throws NoExisteException
{
Elemento elemento = new Elemento( elem );
if( primerElemento == null )
throw new NoExisteException( "Elemento no existe" );
else if( elemento.obtenerValor( ) == primerElemento.obtenerValor( ) )
{
// Se debe eliminar el primer elemento de la lista
primerElemento = primerElemento.desconectarPrimero( );
cantidadElementos--;
}
else
{
for( Elemento p = primerElemento.obtenerSiguiente( ); p != null; p =
p.obtenerSiguiente( ) )
if( p.obtenerValor( ) == elemento.obtenerValor( ) )
{
p.desconectarNodo( );
cantidadElementos--;
return;
}
throw new NoExisteException( "Elemento no existe" );
}
}
/**
* Informa si existe un elemento dado dentro de la estructuraBolsa
* <b>post:</b> Retorna true si elem es encontrado
* @param elem Elemento que va a ser buscado
* @return true si encontró el elemento, false de lo contrario
*/
public boolean buscar( int elem )
{
Elemento elemento = new Elemento( elem );
for( Elemento p = primerElemento; p != null; p = p.obtenerSiguiente( ) )
if( p.obtenerValor( ) == elemento.obtenerValor( ) )
return true;
return false;
}
/**
* Retorna el elemento que se encuentra en la posición pos de la
estructuraBolsa, suponiendo que los elementos están situados ordenados de manera
ascendentemente
* <b>pre:</b> 1 <= pos <= cantidadElementos <br>
* <b>post:</b> Se retorna el valor del elemento en la posición pos <br>
* @param pos Posición del elemento que se quiere buscar
* @return Elemento que se encuentra en la posición pedida
* @throws NoExisteException Se lanza la excepción si no se encuentra la
posición pedida

13. */
public int retornar( int pos ) throws NoExisteException
{
if( pos > cantidadElementos )
throw new NoExisteException( "La posición que desea se encuentra
fuera del rango" );
else
{
Elemento temp = primerElemento;
for( int i = 1; i < pos; i++ )
temp = temp.obtenerSiguiente( );
return temp.obtenerValor( );
}
}
/**
* Retorna el número de elementos de la estructuraBolsa
* <b>post:</b> Retorna cantidadElementos <br>
* @return Longitud de la estructuraBolsa
*/
public int darLongitud( )
{
return cantidadElementos;
}
/**
* Retorna el límite inferior de la estructuraBolsa
* <b>post:</b> Retorna inferior <br>
* @return Límite inferior de la estructuraBolsa
*/
public int darInferior( )
{
return inferior;
}
/**
* Retorna el límite superior de la estructuraBolsa
* <b>post:</b> Retorna superior <br>
* @return Límite superior de la estructuraBolsa
*/
public int darSuperior( )
{
return superior;
}
/**
* Retorna un iterador sobre los elementos de la estructuraBolsa
* @return Un iterador sobre los elementos de la estructuraBolsa
*/
/* public IIteradorBolsa darIterador( )
{
IteradorBolsa1 iterador = new IteradorBolsa1( primerElemento );
return iterador;
}
*/

14. }
/*/*/*/*/*/
/**
* Clase que representa un elemento de una estructuraBolsa
*/
public class Elemento
{
// -----------------------------------------------------------------
// Atributos
// -----------------------------------------------------------------
/**
* El elemento que se tiene después del actual
*/
private Elemento siguiente;
/**
* El elemento que se tiene antes del actual
*/
private Elemento anterior;
/**
* Valor del elemento
*/
private int valor;
// -----------------------------------------------------------------
// Constructores
// -----------------------------------------------------------------
/**
* Constructor por parámetros
* @param pValor Valor
*/
public Elemento( int pValor )
{
valor = pValor;
siguiente = null;
}
// -----------------------------------------------------------------
// Métodos
// -----------------------------------------------------------------

15. /**
* Retorna el valor que tiene el elemento
* @return Valor
*/
public int obtenerValor( )
{
return valor;
}
/**
* Inserta el nodo antes del actual.
* @param nodo Nodo a insertar
*/
public void insertarAntes( Elemento nodo )
{
nodo.siguiente = this;
nodo.anterior = anterior;
if( anterior != null )
anterior.siguiente = nodo;
anterior = nodo;
}
/**
* Inserta el nodo después del actual.
* @param nodo Nodo a insertar
*/
public void insertarDespues( Elemento nodo )
{
nodo.siguiente = siguiente;
nodo.anterior = this;
if( siguiente != null )
siguiente.anterior = nodo;
siguiente = nodo;
}
/**
* Desconecta el nodo de la lista suponiendo que es el primero. <br>
* @return Nodo con el cual comienza la lista ahora
*/
public Elemento desconectarPrimero( )
{
Elemento p = siguiente;
siguiente = null;
if( p != null )
{
p.anterior = null;
}
return p;
}
/**
* Desconecta el nodo de la lista suponiendo que no es el primero.
*/
public void desconectarNodo( )

16. {
Elemento ant = anterior;
Elemento sig = siguiente;
anterior = null;
siguiente = null;
ant.siguiente = sig;
if( sig != null )
sig.anterior = ant;
}
/**
* Retorna el siguiente elemento al actual
* @return Elemento, pude ser null
*/
public Elemento obtenerSiguiente( )
{
return siguiente;
}
/**
* Representación en String del elemento
*/
public String toString( )
{
return "" + valor;
}
}
public class FueraLimiteException extends Exception{
FueraLimiteException(String m)
{
super(m);
}
}
/**
* Clase que representa a un iterador que va a utilizar un apuntador a un primer
elemento
*/
public class IteradorBolsa1
{

17. // -----------------------------------------------------------------
// Atributos
// -----------------------------------------------------------------
/**
* Elemento al que apunta el iterador
*/
private Elemento elemento;
// -----------------------------------------------------------------
// Constructores
// -----------------------------------------------------------------
/**
* Constructor del iterador
* @param primerElemento Primer elemento del iterador
*/
public IteradorBolsa1( Elemento primerElemento )
{
elemento = primerElemento;
}
// -----------------------------------------------------------------
// Métodos
// -----------------------------------------------------------------
/*
* (non-Javadoc)
*
* @see uniandes.cupi2.bolsa.mundo.IIteradorBolsa#darSiguiente()
*/
public int darSiguiente( )
{
if( elemento != null )
{
int valor = elemento.obtenerValor( );
elemento = elemento.obtenerSiguiente( );
return valor;
}
else
return Integer.MAX_VALUE;
}
/*
* (non-Javadoc)
*
* @see uniandes.cupi2.bolsa.mundo.IIteradorBolsa#haySiguiente()
*/
public boolean haySiguiente( )
{
return elemento == null ? false : true;
}
}

18. public class NoExisteException extends Exception{
NoExisteException(String m)
{
super(m);
}
}