Cola de prioridad
Publicado por Lucas (23 intervenciones) el 02/12/2020 15:27:53
Buenas tardes, estoy creando una cola de prioridad con un montículo(heap) y no consigo insertar los elementos. El error que me da es el siguiente:
Exception in thread "main" java.lang.Error: Unresolved compilation problems:
The method insertar(Comparable) in the type Monticulo is not applicable for the arguments (Usuario)
El método utilizado es:
Las clases utilizadas son las siguientes:
Clase ColaPrioridad:
Clase Monticulo
Gracias,
Lucas
Exception in thread "main" java.lang.Error: Unresolved compilation problems:
The method insertar(Comparable) in the type Monticulo is not applicable for the arguments (Usuario)
El método utilizado es:
1
2
3
4
5
6
7
8
9
10
11
12
13
//creamos el control de entrada con una cola de prioridadMonticulo controlEntrada = new Monticulo(50);
/*Insertamos a los usuarios en el monticulo (cola de prioridad), los introducimos en este orden,* pero dependiendo de su prioridad se insertaran en los prioritarios al principio de la cola*/controlEntrada.insertar(cliente3); //usuario sin prioridad
controlEntrada.insertar(cliente5);// usuario con prioridad
controlEntrada.insertar(cliente4); //usuario sin prioridad
controlEntrada.insertar(cliente1);// usuario con prioridad
controlEntrada.insertar(cliente6);// usuario con prioridad
Las clases utilizadas son las siguientes:
Clase ColaPrioridad:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
package monticulos;
/** Este interfaz define las operaciones de una cola de prioridad. **/public interface ColaPrioridad { /** * Añade un elemento en la cola de prioridad. El nivel de prioridad se puede * comparar usando la comparación propia de los elementos. Se asume que el * elemento que resulta menor de la comparación tiene mayor nivel de prioridad. **/public void insertar(Comparable elemento);
/** * Devuelve el elemento mínimo de la cola de prioridad. En concreto este es el * primer elemento de la cola. Esta operación no altera la cola de prioridad. **/public Comparable obtenerMinimo();
/** * Elimina el elemento mínimo de la cola de prioridad, que es el primer elemento * de la cola de prioridad. **/void eliminarMinimo();
/** * Determina si la cola de prioridad está vacía. Es decir, devuelve cierto si y * solo si la cola de prioridad no tiene ningún elemento. **/boolean esVacia();
}Clase Monticulo
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
package monticulos;
import excepciones.DesbordamientoInferior;/** * Esta clase implementa un montículo, que es una implementación eficiente de la * cola de prioridad **/public class Monticulo implements ColaPrioridad { /** * Este vector tiene los elementos del montículo. En esta representación, cada * nodo en la posición x tiene sus hijos en x*2 y x*2+1, y el nodo raíz está * situado en la posición uno. */private Comparable[] datos;
/** Número de elementos del montículo **/int numElementos;
/** * Constructor de la clase. Crea el montículo con la capacidad indicada por el * parámetro. */public Monticulo(int capacidad) {
/* * Se crea el vector vacío con el tamaño "capacidad + 1", dado que la posición * cero no se usa */datos = new Comparable[capacidad + 1];
numElementos = 0; } /** * Añade un elemento en la cola de prioridad. El nivel de prioridad se puede * comparar usando la comparación propia de los elementos. Se asume que el * elemento que resulta menor de la comparación tiene mayor nivel de prioridad. **/public void insertar(Comparable elemento) {
// Variables para determinar la posición del nuevo elemento insertado y de su // padre int posElemento, posPadre; /* * Si se ha llegado a la capacidad máxima del montículo, se avisa que el * montículo está lleno */if (numElementos + 1 >= datos.length) {
System.out.println("No se puede insertar el elemento, porque el montículo está lleno");
} else {
// Se inserta el nuevo elemento en la primera posición libre del montículodatos[numElementos + 1] = elemento;
posElemento = numElementos + 1;
numElementos++;
/* * Mientras el elemento no está en la raíz y sea menor que su padre, se flota el * elemento. */posPadre = posElemento / 2;
while (posPadre >= 1 && datos[posElemento].compareTo(datos[posPadre]) < 0) {
// Se intercambian los elementosintercambiar(posElemento, posPadre);
// Se actualiza la posición del elemento y de su nuevo padre posElemento = posPadre;posPadre = posElemento / 2;
} } } /** * Intercambia los dos elementos que se encuentran en las posiciones indicadas * por los parámetros **/private void intercambiar(int primeraPos, int segundaPos) {
Comparable tmp = datos[primeraPos];
datos[primeraPos] = datos[segundaPos];
datos[segundaPos] = tmp;
} /** Devuelve el elemento mínimo de la cola de prioridad. * En concreto, este es el primer elemento de la cola. * Esta operación no altera la cola de prioridad. **/public Comparable obtenerMinimo() throws DesbordamientoInferior {
// Se comprueba si está vacía la colaif(esVacia()){
throw new DesbordamientoInferior("No se puede obtener el mínimo elemento porque el montículo está vacío");
}else{
/* Devuelve el elemento que está en la raíz, que está en la posición uno delvector */return datos[1];
} } /** Elimina el elemento mínimo de la cola de prioridad, * que es el primer elemento de la cola de prioridad. **/public void eliminarMinimo() throws DesbordamientoInferior{
// Variable con las posiciones del elemento hundido y sus hijos izquierdo y derechoint posHundido, posIzq, posDch;
// Se comprueba si está vacío el montículoif(esVacia()){
throw new DesbordamientoInferior("No se puede eliminar el elemento mínimo, porque el montículo está vacío");
}else{
// Se coloca el elemento de la última posición en la raízdatos[1]=datos[numElementos];
numElementos--;
/* Se empieza el hundimiento en la raíz y se actualizan sus hijos izquierdo y derecho*/ posHundido=1;posIzq=hijoIzquierdo(posHundido);
posDch=hijoDerecho(posHundido);
/* Se produce el proceso de hundimiento mientras se tenga algún hijo menor o igual que el elemento hundido*/while((posIzq>=0 && datos[posIzq].compareTo(datos[posHundido])<=0)||
(posDch>=0 && datos[posDch].compareTo(datos[posHundido])<=0)){
/* Si tiene los dos hijos se escoge el menor y se compara con el elemento hundido*/if(posIzq>=0 && posDch>=0){
/* Si el hijo izquierdo es menor que el hijo derecho y menor o igual que el elemento hundido, se intercambia*/if(datos[posIzq].compareTo(datos[posDch])<0 &&
datos[posIzq].compareTo(datos[posHundido])<=0){
intercambiar(posHundido,posIzq);
posHundido=posIzq; /* Si el hijo derecho es menor o igual que el hijo izquierdo y menor o igual que el elemento hundido, se intercambia*/}else if (datos[posDch].compareTo(datos[posIzq])<=0 &&
datos[posDch].compareTo(datos[posHundido])<=0){
intercambiar(posHundido,posDch);
posHundido=posDch; } // Si solo tiene un hijo, se compara con el elemento hundido}else if (posIzq>=0 && posDch<0){
/* Si el hijo izquierdo es menor que el elemento hundido, se produce el intercambio */if(datos[posIzq].compareTo(datos[posHundido])<=0){
intercambiar(posHundido,posIzq);
posHundido=posIzq; } } // Se actualiza las posiciones de los hijos izquierdo y derechoposIzq=hijoIzquierdo(posHundido);
posDch=hijoDerecho(posHundido);
} } } /** * Determina la posición del hijo izquierdo del elemento en la posición pasada * por parámetro. En caso de no existir, devuelve –1. **/private int hijoIzquierdo(int posicion) {
if (posicion * 2 <= numElementos) {
return posicion * 2;} else {
return -1; } } /** * Determina la posición del hijo izquierdo del elemento en la posición pasada * por parámetro. En caso de no existir, devuelve –1. **/private int hijoDerecho(int posicion) {
if (posicion * 2 + 1 <= numElementos) {
return posicion * 2 + 1;
} else {
return -1; } } /** Determina si la cola de prioridad está vacía. Es decir, * devuelve cierto si y solo si la cola de prioridad no * tiene ningún elemento. **/public boolean esVacia() {
return (numElementos<=0);
}}Gracias,
Lucas
Valora esta pregunta
0
