A implementação de uma pilha baseada em matriz em Java envolve o uso de uma matriz para representar a estrutura da pilha. Usaremos um min-heap como exemplo (menor elemento da raiz), mas os princípios são os mesmos para um max-heap.
Aqui está uma implementação de Java de um min-heap, incluindo métodos de inserção, extração do elemento mínimo e operações Heappify:
`` `Java
classe pública MINNHEAP {
private int [] heap;
Tamanho privado int;
Capacidade privada int;
public MINNHEAP (INT Capacidade) {
this.Capacity =Capacidade;
this.heap =new int [capacidade + 1]; // O índice 0 não é usado
this.size =0;
}
public boolean isEmpty () {
tamanho de retorno ==0;
}
public boolean isfull () {
tamanho de retorno ==capacidade;
}
private int parent (int i) {
retornar i / 2;
}
private int esquerd (int i) {
retornar 2 * i;
}
private int certo (int i) {
retornar 2 * i + 1;
}
troca de vazio privado (int i, int j) {
int temp =heap [i];
heap [i] =heap [j];
heap [j] =temp;
}
public void insert (int key) {
if (isfull ()) {
lançar novas ilegalstateException ("Heap está cheio");
}
tamanho ++;
heap [size] =chave;
int i =tamanho;
while (i> 1 &&heap [parent (i)]> heap [i]) {// Propriedade min-hap
troca (i, pai (i));
i =pai (i);
}
}
public int extractMin () {
if (isEmpty ()) {
jogue nova ilegalStateException ("Heap está vazio");
}
int root =heap [1];
heap [1] =heap [size];
tamanho--;
heapify (1);
ROOT ROOT;
}
private vazio heapify (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);
heapify (menor);
}
}
public void Primtheap () {
for (int i =1; i <=size; i ++) {
System.out.print (heap [i] + "");
}
System.out.println ();
}
public static void main (string [] args) {
MINHEAP MINNHEAP =novo MINHEAP (10);
mineap.insert (3);
mineap.insert (2);
mineap.insert (15);
mineap.insert (5);
mineap.insert (4);
mineap.insert (45);
System.out.println ("MINHEAP Array:");
mineap.priripation ();
System.out.println ("Extract min:" + minhap.extractmin ());
System.out.println ("Após extrair min:");
mineap.priripation ();
}
}
`` `
Este código inclui:
* Construtor: Inicializa a matriz de heap com uma determinada capacidade. Observe que o índice 0 não é usado.
* `isEmpty ()` e `isfull ()`: Verifique o estado da pilha.
* `parent ()`, `esquerda ()`, `right ()`: Helper funciona para obter os índices dos nós pais e filhos.
* `swap ()`: Troque dois elementos na matriz.
* `insert ()`: Insira um novo elemento na pilha, mantendo a propriedade Min-Heap.
* `extractmin ()`: Remove e retorna o elemento mínimo (raiz), mantendo a propriedade Min-Heap usando `heapify ()`.
* `heapify ()`: Restaura a propriedade Min-Heap após a remoção ou inserido um elemento. Ele compara recursivamente um elemento com seus filhos e swaps, se necessário.
* `PRINTHTHEAP ()`: Uma função auxiliar para demonstração.
Lembre -se de lidar com possíveis exceções, como tentar extrair de uma pilha vazia ou inserir em uma completa. Este exemplo usa valores inteiros; Você pode adaptá -lo facilmente a outros tipos de dados usando um parâmetro de tipo genérico. Para montes maiores, considere usar uma estratégia de redimensionamento mais sofisticada para evitar a limitação da capacidade fixa.
