A implementação de um heap baseado em matriz (min-heap neste exemplo) em Java envolve o uso de uma única matriz para representar a estrutura da pilha. Veja como você pode fazer isso, incluindo métodos de inserção, exclusão (extração do elemento mínimo) e espiar (obtendo o elemento mínimo sem removê -lo):

`` `Java
classe pública ArrayHeap {

private int [] heap;
Tamanho privado int;
Capacidade privada int;

public ArrayHeap (INT Capacidade) {
this.Capacity =Capacidade;
this.heap =new int [capacidade + 1]; // O índice 0 não é usado
this.size =0;
}

// função auxiliar para obter o índice pai
private int parent (int i) {
retornar i / 2;
}

// função auxiliar para obter o índice infantil esquerdo
private int esquerd (int i) {
retornar 2 * i;
}

// função auxiliar para obter o índice infantil certo
private int certo (int i) {
retornar 2 * i + 1;
}

// função auxiliar para aumentar após a inserção
private vazio heapifyup (int i) {
while (i> 1 &&heap [parent (i)]> heap [i]) {
troca (i, pai (i));
i =pai (i);
}
}

// função auxiliar para abaixar após a exclusão
private vazio heapifydown (int i) {
int menor =i;
int l =esquerda (i);
int r =certo (i);

if (l <=size &&heap [l] menor =L;
}
if (r <=size &&heap [r] menor =r;
}

if (menor! =i) {
trocar (i, menor);
heapifydown (menor);
}
}

// função auxiliar para trocar dois elementos
troca de vazio privado (int i, int j) {
int temp =heap [i];
heap [i] =heap [j];
heap [j] =temp;
}


// Insira um novo elemento na pilha
public void insert (int key) {
if (size ==Capacidade) {
lançar novas ilegalstateException ("Heap está cheio");
}
tamanho ++;
heap [size] =chave;
heapifyUp (tamanho);
}

// extraia (e remova) o elemento mínimo
public int extractMin () {
if (size ==0) {
jogue nova ilegalStateException ("Heap está vazio");
}
int min =heap [1];
heap [1] =heap [size];
tamanho--;
heapifyDown (1);
retornar min;
}

// Obtenha o elemento mínimo sem removê -lo
public int peekmin () {
if (size ==0) {
jogue nova ilegalStateException ("Heap está vazio");
}
retorno heap [1];
}

// Verifique se a pilha está vazia
public boolean isEmpty () {
tamanho de retorno ==0;
}

public static void main (string [] args) {
ArrayHeap heap =new ArrayHeap (10);
heap.insert (10);
heap.insert (5);
heap.insert (15);
heap.insert (3);
heap.insert (8);

System.out.println ("Elemento mínimo:" + heap.peekmin ()); // Saída:3
System.out.println ("Elemento mínimo extraído:" + heap.extractmin ()); // Saída:3
System.out.println ("novo elemento mínimo:" + heap.peekmin ()); // saída:5

}
}
`` `

Esta implementação fornece operações básicas de heap. Lembre-se de que isso é um *min-heap *; Para torná-lo um *max-heap *, você precisará reverter a lógica de comparação em `heapifyUp` e` heapifydown`. Para montes maiores, considere o uso de uma estrutura de dados ou biblioteca mais sofisticada se o desempenho se tornar crítico. Você também pode estender isso para lidar com genéricos para tipos de dados mais versáteis. Lembre -se de lidar com possíveis exceções como `ilegalStateException` para montes vazios ou completos.