`` `Java
ARRAYHEAP de clase pública {
privado int [] Heap;
tamaño privado int;
Capacidad privada int;
Public ArrayHeap (int capacidad) {
this.capacity =capacidad;
this.heap =new int [capacidad + 1]; // El índice 0 no se usa
this.size =0;
}
// Función auxiliar para obtener el índice principal
Private Int Parent (int i) {
regresar i / 2;
}
// función de ayuda para obtener el índice infantil izquierdo
Private int Left (int i) {
regresar 2 * i;
}
// función de ayuda para obtener el índice infantil adecuado
Private int Right (int i) {
return 2 * i + 1;
}
// función de ayuda para acumular después de la inserción
Private Void HeapifyUp (int i) {
while (i> 1 &&Heap [parent (i)]> Heap [i]) {
intercambio (i, padre (i));
i =padre (i);
}
}
// función de ayuda para acumular después de la eliminación
Private Void HeapifyDown (int i) {
int más pequeño =i;
int l =izquierda (i);
int r =right (i);
if (l <=size &&Heap [l]
}
if (r <=size &&Heap [r]
}
if (más pequeño! =i) {
intercambio (i, más pequeño);
HeapifyDown (más pequeño);
}
}
// función de ayuda para intercambiar dos elementos
swap vacío privado (int i, int j) {
int temp =Heap [i];
Heap [i] =Heap [J];
montón [j] =temp;
}
// inserta un nuevo elemento en el montón
Public void Insert (int key) {
if (size ==capacidad) {
tirar nueva ilegalstateException ("el montón está lleno");
}
tamaño ++;
montón [tamaño] =clave;
HeapifyUp (tamaño);
}
// extraer (y eliminar) el elemento mínimo
public int ExtractMin () {
if (size ==0) {
tirar nueva IllegalStateException ("el montón está vacío");
}
int min =montón [1];
montón [1] =montón [tamaño];
tamaño--;
HeApifyDown (1);
regresar min;
}
// Obtener el elemento mínimo sin eliminarlo
public int peekmin () {
if (size ==0) {
tirar nueva IllegalStateException ("el montón está vacío");
}
devolver el montón [1];
}
// Compruebe si el montón está vacío
Public boolean isEtimty () {
tamaño de retorno ==0;
}
public static void main (string [] args) {
ArrayHeap Heap =New ArrayHeap (10);
Heap.insert (10);
montón.insert (5);
montón.insert (15);
montón.insert (3);
montón.insert (8);
System.out.println ("Elemento mínimo:" + Heap.peekmin ()); // Salida:3
System.out.println ("Elemento mínimo extraído:" + Heap.extractmin ()); // Salida:3
System.out.println ("nuevo elemento mínimo:" + Heap.peekmin ()); // Salida:5
}
}
`` `` ``
Esta implementación proporciona operaciones de montón básicas. Recuerda que este es un *min-heap *; Para que sea *Max-Heap *, necesitaría revertir la lógica de comparación en `HeapifyUp` y` HeapifyDown`. Para montones más grandes, considere usar una estructura de datos o biblioteca más sofisticada si el rendimiento se vuelve crítico. También puede extender esto para manejar genéricos para tipos de datos más versátiles. Recuerde manejar posibles excepciones como `ilegalStateException` para montones vacíos o completos.