Pilha máxima
A maior pilha é que o elemento pai é maior que o elemento filho e é uma árvore completamente binária.
Os dados [1] começam a salvar, os dados [0] estão vazios e não usados. Você também pode usar os dados [0] como tamanho.
Classe pública maxheap <t estende comparável <?? super t >> {private t [] dados; private int size; private int capacidade; public maxheap (int capacidade) {this.data = (t []) novo comparável [capacidade + 1]; size = 0; this.capacity = capacidade;} public int size () {return this.size;} public boolean isEmpty () {Tamanho {Size 0; this.capacity;}/** * @return Visualize a raiz máxima (veja apenas sem exclusão, em comparação com POPMAX) */public t SeekMax () {retorna dados [1];} public void swap (int i, int j) {if (i! {size ++; dados [size] = item; shiftUp (size);}/*** @return Pop a raiz máxima (pop-up significa deleção, em comparação com SeekMax)*/public t POPMAX () {SWAP (1, tamanho); Chill Derning Child Derl of Child Derl of Child of Child Derl of the Child Derl of the Child Derl of the Child do Child Derl Derl Derl of Child do Child Derning, que é o que é o que é o que é o que é o que é o que é o que é que você precisa saber, o que você está fazendo? * / public void shiftUp (int criança) {while (criança> 1 && data [filho] .compareto (dados [filho / 2])> 0) {swap (filho, filho, filho / 2); filho = filho / 2;}}} / ** ** ** @param Uma marca de canto inferior de um elemento em um elemento de dados* @param b inferior marca de um elemento de um elemento no final do canto mais baixo do canto mais baixo* max (int a, int b) {if (dados [a] .compareto (dados [b]) <0) {// se dados [b] grande retorno b; // retorna b} else {// se dados [a] retornam a; // retorna a}}}/** ** @mark de um canto inferior do elemento de um elemento na prisão de dados* Na matriz de dados*@return Retornar a marca do canto inferior, cuja elemento é grande*/privado int max (int a, int b, int c) {int maior = max (a, b); maior = max (maior, c); retornar maior;}/***@param pai A marca do canto inferior do nó pai é pai e os nó do canto mais baixo*dos nomes da esquerda*** pai) {while (true) {int lchild = pai * 2; // filho esquerdo int rchild = pai * 2 + 1; // filho direito no novato = pai; // o novato está prestes a ser atualizado. Quem é a marca do canto inferior dos pais, nós à esquerda e direita? If (lchild> size) {// se o nó do pai não tiver o filho esquerdo nem o filho direito retornar;} else if (rchild> size) {// se o nó do pai tiver apenas o filho esquerdo, nenhum filho direito de novo = maxild (father, lchild);} mais {// se o pai tivesse o filho da esquerda e o filho direto, o filho da esquerda; == pai) {// significa que o pai é maior que os nós da criança, e o nome da tabela já é um grande monte de raiz, portanto, não há necessidade de continuar ajustando o retorno;} mais {//, caso contrário, você precisa continuar ajustando a pilha até que a grande condição da raiz seja atendida (o pai, o pai); // Os valores são o mesmo que a swap = shop shop; shiftDown (novato)}}} public static void main (string [] args) {// cria um grande heap de raiz maxheap <preger> maxheap = new maxheap <preger> (100); // salvar (int i = 0; i <100; i ++) {maxheap.insert (int) (int) Inteiro [] arr = novo número inteiro [100]; // Escolha da pilha e coloque -o na matriz para (int i = 0; i <100; i ++) {arr [i] = maxheap.popmax (); System.out.print (arr [i]+"");} System.out.println ();HEAP MAISTURA: a função shiftDown () é diferente do acima
Classe pública maxheap <t estende comparável <?? super t >> {private t [] dados; private int size; private int capacidade; public maxheap (int capacidade) {data = (t []) novo comparável [capacidade + 1]; this.capacity = capacidade; tamanho = 0;} public int size () {Tamanho de retorno;} public boolean isEmpty () {time === 0; item; tamanho ++; shiftUp (tamanho);}/** * @return pop max root (pop-up significa exclusão, em comparação com seekmax) */public t POPMAX () {t ret = dados [1]; swap (1, tamanho); size), size (apenas shiftDown (1); retornar Ret; dados [1];} public void swap (int i, int j) {if (i! 2;}} public void shiftDown (int pai) {while (2 * pai <= size) {int newfather = 2 * pai; if (recém -saído + 1 <= size && Data [sizefather + 1] .compareto (dados de dados [Newfather])> 0) {// Data [J] Data [j + 1] aquele que requer o grande (Dados [pai] .Compareto (Data [Newfather])> = 0) {break;} else {swap (pai, novato); // O valor é trocado pai = novo; // strings do novo (2*Public) ou (2*pai), isto é, Shiftdown (stringsdown (}}}}} Public. Maxheap <Teger> maxheap = new maxheap <preger> (100); // salvar (int i = 0; i <100; i ++) {maxheap.insert ((int) (math.random () * 100));} // criar um array integger [] e newneger [100]; 100;Resumir
O exposto acima é tudo sobre o exemplo do código de heap máximo de implementação de idiomas Java, e espero que seja útil para todos. Amigos interessados podem continuar se referindo a outros tópicos relacionados neste site. Se houver alguma falha, deixe uma mensagem para apontá -la. Obrigado amigos pelo seu apoio para este site!