Apartado 11.

2, Cola de prioridades con una tabla de colas

package ColaPrioridad;
import TipoCola.ColaLista;
public class ColaPrioridadT
{
protected ColaLista []tabla;
protected int maxPrioridad;

public ColaPrioridadT(int n) thros !xception
{
i" (n # $)
thro ne !xception (%!rror en prioridad& % ' n);
maxPrioridad ( n;
tabla ( ne ColaLista[maxPrioridad ' $];
"or (int i ( ); i #( maxPrioridad; i'')
tabla[i] ( ne ColaLista();
*
public +oid inser!nPrioridad(Tarea t)thros !xception
{
int p ( t.numPrioridad();
i" (p ,( ) -- p #( maxPrioridad)
{
tabla[p].insertar(t);
*
else
thro ne !xception(%Tarea con prioridad "uera de rango%);
*

public Tarea elemento.in()thros !xception
{
int i ( );
int indiceCola ( /$;
00 b1s2ueda de la primera cola no +ac3a
do {
i" (4tabla[i].cola5acia())
{
indiceCola ( i;
i ( maxPrioridad '$; 00 termina el bucle
*
else
i'';
*hile (i #( maxPrioridad);

i" (indiceCola 4( /$)
return (Tarea) tabla[indiceCola]."renteCola();
else
thro ne !xception(%Cola de prioridades +ac3a%);
*

public Tarea 2uitar.in()thros !xception
{
int i ( );
int indiceCola ( /$;
00 b1s2ueda de la primera cola no +ac3a
do {
i" (4tabla[i].cola5acia())
{
indiceCola ( i;
i ( maxPrioridad '$;00 termina el bucle
*
else
i'';
*hile (i #( maxPrioridad);

i" (indiceCola 4( /$)
return (Tarea) tabla[indiceCola].2uitar();
else
thro ne !xception(%Cola de prioridades +ac3a%);
*

public boolean colaPrioridad5acia()
{
int i ( );
hile (tabla[i].cola5acia() -- i # maxPrioridad)
i'';
return tabla[i].cola5acia();
*
*
Apartado 11.3, Colas de prioridades con vector
package ColaPrioridad;
import 6a+a.util.5ector;
public class ColaPrioridad5
{
protected 5ector cp;
public ColaPrioridad5()
{
cp ( ne 5ector();
*

public +oid inser!nPrioridad(Tarea t)thros !xception
{
i" (t.numPrioridad() # ))
thro ne !xception(%Tarea con prioridad "uera de rango%);
00 b1s2ueda de la posici7n de inserci7n
Tarea a;
int p ( );
int n ( cp.si8e();
hile (p # n)
{
a ( (Tarea) cp.element9t(p);
i" (a.numPrioridad() #( t.numPrioridad())
p'';
else
n ( p / $;
*
cp.insert!lement9t(t:p);00 despla8a elementos posteriores
*

public Tarea elemento.in()thros !xception
{
i" (colaPrioridad5acia())
thro ne !xception(%Cola de prioridades +ac3a%);
return (Tarea) cp.element9t());
*

public Tarea 2uitar.in()thros !xception
{
i" (colaPrioridad5acia())
thro ne !xception(%Cola de prioridades +ac3a%);
Tarea a ( (Tarea)cp.element9t());
cp.remo+e!lement9t());
return a;
*

public boolean colaPrioridad5acia()
{
return cp.si8e() (( );
*
*
Apartado 11.4, Montculo Binario
public class .onticulo
{
static "inal int T9.;<; ( =);
public static int padre(int i)
{
return (i / $)0 =;
*
public static int hi6o;82(int i)
{
return (= > i ' $);
*
public static int hi6o?er(int i)
{
return (= > i ' $) ' $;
*
pri+ate int num!lem;
pri+ate Comparador [] +;
public .onticulo()
{
num!lem ( );
+ ( ne Comparador [T9.;<;];
*
pri+ate +oid "lotar(int i)
{
Comparador nue+aCla+e ( +[i];
hile ((i , )) -- (+[padre(i)].ma@orAue(nue+aCla+e)))
{
+[i] ( +[padre(i)];00 ba6a el padre al hueco
i ( padre(i); 00 sube un ni+el en el Brbol
*
+[i] ( nue+aCla+e; 00 sit1a la cla+e en su posici7n
*
pri+ate boolean monticuloLleno()
{
return (num!lem (( +.length);
*
pri+ate +oid ampliar()
{
Comparador [] anterior5 ( +;
+ ( ne Comparador [num!lem ' T9.;<;];
"or (int 6 ( ); 6 # num!lem; 6'')
+[6] ( anterior5[6];
*
public +oid insertar (Comparador cla+e)
{
i" (monticuloLleno())
{
ampliar();
*
+[num!lem] ( cla+e;
"lotar(num!lem);
num!lem'';
*
public Comparador buscar.inimo() thros !xception
{
i" (es5acio())
thro ne !xception(%9cceso a mont3culo +ac3o%);
return +[)];
*
public +oid criba (int rai8)
{
boolean es.onticulo;
int hi6o;
es.onticulo ( "alse;
hile ((rai8 # num!lem 0 =) -- 4es.onticulo)
{
00 determina el 3ndice del hi6o menor
i" (hi6o;82(rai8) (( (num!lem / $)) 00 1nico descendiente
hi6o ( hi6o;82(rai8);
else
{
i" (+ [hi6o;82(rai8)] .menorAue(+ [hi6o?er(rai8)] ))
hi6o ( hi6o;82(rai8);
else
hi6o ( hi6o?er(rai8);
*
00 compara rai8 con el menor de los hi6os
i" (+[ hi6o ] .menorAue(+ [rai8] ))
{
Comparador t ( + [rai8] ;
+[rai8] ( + [hi6o] ;
+ [hi6o] ( t;
rai8 ( hi6o; 0> continua por la rama
de cla+es m3nimas >0
*
else
es.onticulo ( true;
*
*
public Comparador eliminar.inimo() thros !xception
{
i" (es5acio())
thro ne !xception(%9cceso a mont3culo +ac3o%);
Comparador menor;
menor ( +[)];
+[)] ( +[num!lem / $];
criba());
num!lem//;
return menor;
*
public boolean es5acio()
{
return num!lem (( );
*
*
Apartado 11.5, HeapSort (ordenacin por !ontculos"
import ColaPrioridad.Comparador;
import monticuloCinario..onticulo;
import <um!ntero.!ntero;
class DeapEort
{
public static +oid criba= (Comparador +[]: int rai8: int ultimo)
{
boolean es.onticulo;
int hi6o;
int num!lem ( ultimo ' $;
es.onticulo ( "alse;
hile ((rai8 # num!lem 0 =) -- 4es.onticulo)
{
00 determina el 3ndice del hi6o ma@or
i" (.onticulo.hi6o;82(rai8) (( (num!lem / $))
hi6o ( .onticulo.hi6o;82(rai8);
else
{
i" (+ [.onticulo.hi6o;82(rai8)] .ma@orAue(
+[ .onticulo.hi6o?er(rai8)] ))
hi6o ( .onticulo.hi6o;82(rai8);
else
hi6o ( .onticulo.hi6o?er(rai8);
*
00 compara rai8 con el ma@or de los hi6os
i" (+ [hi6o] .ma@orAue(+[ rai8] ))
{
Comparador t ( +[ rai8] ;
+[rai8] ( + [hi6o] ;
+ [hi6o] ( t;
rai8 ( hi6o; 0> continua por la rama
de cla+es mBximas >0
*
else
es.onticulo ( true;
*
*
public static +oid ordenacion.onticulo(Comparador +[]: int n)
{
int 6;
"or (6 ( n 0 =; 6 ,( ); 6//)
criba=(+: 6: n / $);

"or (6 ( n / $; 6 ,( $; 6//)
{
Comparador t;
t ( +[)] ;
+[)] ( +[ 6 ];
+[ 6 ] ( t;
criba= (+: ): 6/$);
*
*
*
Apartado 11.#, Cola prioridad con !ontculo
package ColaPrioridad;
import monticuloCinario..onticulo;
public class ColaPrioridad.
{
protected .onticulo cp;
public ColaPrioridad.()
{
cp ( ne .onticulo();
*
public +oid inser!nPrioridad(Tarea t)thros !xception
{
cp.insertar(t);
*
public Tarea elemento.in ()thros !xception
{
return (Tarea)cp.buscar.inimo();
*
public Tarea 2uitar.in()thros !xception
{
return (Tarea)cp.eliminar.inimo();
*
public boolean colaPrioridad5acia()
{
return cp.es5acio();
*
*

Apartado 11.#.1, $%e!plo Cola de prioridades
import ColaPrioridad.>;
import 6a+a.io.>;
class !+ento extends Tarea
{
public !+ento (Etring proces: int tiempo)
{
super(proces:tiempo);
*
0>
prioridad orden in+erso de tiempo; es decir: tiempo )
ma@or prioridad 2ue tiempo $.
>0
public Etring toEtring()
{
Etring proces;
int tiempo;
proces ( (Etring)super.item;
tiempo ( super.prioridad;
return proces ' % tiempo& % ' tiempo;
*
*
FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF
import ColaPrioridad.ColaPrioridad.;
import 6a+a.io.>;
import 6a+a.util.Gandom;
public class EimulaColaPrioridad
{
public static +oid main(Etring [] ar)
{
Etring pt;
int tm;
Cu""eredGeader entrada ( ne Cu""eredGeader(
ne ;nputEtreamGeader(E@stem.in));
Gandom a ( ne Gandom();
ColaPrioridad. 2uePrio ( ne ColaPrioridad.();
tr@ {
00 bucle para crear e+entos e insertarlos
int cuenta ( );
!+ento e+ento;
do {
E@stem.out.print(%?escripci7n& %);
pt ( entrada.readLine();
tm ( a.next;nt($H); 00simula tiempo de proceso
e+ento ( ne !+ento(pt:tm);
2uePrio. inser!nPrioridad(e+ento);
cuenta'';
* hile (cuenta # $H);
00 listado de e+entos en orden
E@stem.out.println(%Procesos en orden de prioridad%);
E@stem.out.println(%//////////////////////////////%);
hile (42uePrio.colaPrioridad5acia())
{
e+ento ( (!+ento)2uePrio.2uitar.in();
E@stem.out.println(e+ento);
*
*
catch (!xception er)
{
E@stem.err.println(%!rror de acceso a cola& % ' er);
*
*
*