import java.util.

Vector;
/**
* MonticuloBinario: representa un montculo binario
* rbol binario en que cada padre es menor que sus hijos
* @author rcrespo
*
*/
public class MonticuloBinario implements ColaConPrioridad {
/**
* Estructura de datos que almacena la informacin
*/
Vector monticulo;
public MonticuloBinario() {
monticulo = new Vector();
}
/**
* Devuelve el nmero de elementos
*/
public int tamao() {
return monticulo.size();
}
/**
* Indica si est vaco.
*/
public boolean isVacio() {
return monticulo.isEmpty();
}
/**
* Insertar el objeto indicado en la posicin adecuada segn su prioridad.
* La prioridad se indica mediante un nmero natural (>= 0).
* Cuanto mayor es dicho nmero, menor es la prioridad del elemento
* asociado. El valor 1 corresponde a los elementos con prioridad mxima.
*/
public void insertar(int prioridad, Object info) {
ElementoColaPrioridad nuevo = new ElementoColaPrioridad(info, prioridad)
;
int posNuevo = monticulo.size();
int posPadre = (posNuevo-1)/2;
// Agregar nuevo elemento al final del montculo
monticulo.add(nuevo);
// Recolocar el nuevo elemento para mantener el orden
while ( posNuevo > 0
&& prioridad < ((ElementoColaPrioridad) monticulo.get(posPadre))
.getPrioridad()) {
// intercambiar los elementos
monticulo.set(posNuevo, monticulo.get(posPadre));
monticulo.set(posPadre, nuevo);
// recalcular indices

posNuevo = posPadre;
posPadre = (posNuevo-1)/2;
}
}
/**
* Extrae el objeto con mayor prioridad
* (es decir, aqul cuya prioridad tenga valor mnimo)
* Si el montculo est vaco, devuelve null.
*/
public Object extraer() {
Object info = null;
boolean colocado = false;
int posHueco, posHijo1, posHijo2, posHijoMin;
if (!isVacio()) {
// Objeto a recuperar: en la raz del montculo
info = ((ElementoColaPrioridad) monticulo.get(0)).getInfo();
// Eliminar el ltimo elemento
posHueco = tamao() - 1;
ElementoColaPrioridad hueco = (ElementoColaPrioridad) monticulo.
remove(posHueco);

// Reorganizar el montculo (si quedan ms elementos)

if (posHueco > 0) {
// El ltimo elemento pasa a ser la raz
posHueco = 0;
monticulo.set(posHueco, hueco);
// Comprobar orden mientras tenga hijos
posHijo1 = posHueco*2+1;
posHijo2 = posHueco*2+2;
while (!colocado && posHijo1 < tamao()) {
// Hallar el mnimo de los 2 hijos (si existen)
posHijoMin = posHijo1;
if ((posHijo2 < tamao() ) && ((ElementoColaPriori
dad)monticulo.get(posHijo2)).getPrioridad() < ((ElementoColaPrioridad)monticulo.
get(posHijo1)).getPrioridad()) {
posHijoMin = posHijo2;
}
// Comparar el hijo menor con el nuevo padre
if (hueco.getPrioridad() > ((ElementoColaPriorid
ad)monticulo.get(posHijoMin)).getPrioridad()) {
// hueco > hijo => intercambiar
monticulo.set(posHueco, monticulo.get(po
sHijoMin));
monticulo.set(posHijoMin, hueco);
// recalcular indices
posHueco = posHijoMin;
posHijo1 = posHueco*2+1;
posHijo2 = posHueco*2+2;
} else {
// est en la posicin correcta

colocado = true;
}
}
}
}
return info;
}
/**
* Imprime por pantalla los elementos almacenados junto con su prioridad,
* en orden segn su posicin en el montculo.
*/
public void print() {
for (int i=0; i<monticulo.size(); i++) {
System.out.println(((ElementoColaPrioridad) monticulo.get(i)).to
String());
}
}
}