A classificação de heap refere -se a um algoritmo de classificação projetado usando a estrutura de dados da heap. O empilhamento é uma estrutura que é aproximadamente completamente binária e satisfaz as propriedades do empilhamento: ou seja, o valor da chave ou o índice de um nó filho é sempre menor que (ou maior que) seu nó pai.
A complexidade média do tempo do tipo de heap é (nLogn).
Etapas do algoritmo:
1. Crie uma pilha H [0..n-1]
2. Troque a cabeça da pilha (no máximo) e a cauda de heap
3. Reduza o tamanho da pilha em 1 e o shift_down de chamada (0). O objetivo é ajustar os dados superiores da nova matriz para a posição correspondente.
4. Repita a etapa 2 até que o tamanho da pilha seja 1
pilha:
O heap é na verdade uma árvore completamente binária, e qualquer nó não folhas de seu nó não folhas satisfaz suas propriedades: Key [i] <= key [2i+1] && key [i] <= key [2i+2] ou key [i]> key [2i+1] && key> = key [não 2] que é, o que não é o que não é, o que não é o que não é, o que não é o que não é, o que não é a chave [2i+1] e a chave. A pilha é dividida em uma pilha superior grande e em uma pequena pilha superior. Uma chave satisfatória [i]> = chave [2i+1] && key> = key [2i+2] é chamada de grande heap superior. Uma chave satisfatória [i] <= key [2i+1] && key [i] <= key [2i+2] é chamada de pequena pilha superior. A partir das propriedades acima, podemos ver que as palavras -chave na parte superior da grande pilha superior são definitivamente as maiores de todas as palavras -chave e as palavras -chave na parte superior da pequena pilha superior são as menores de todas as palavras -chave.
Ideia de classificação de heap:
O recurso da maior palavra -chave (palavra -chave mínima) que é registrada na parte superior da grande pilha superior (heap top small) simplifica a seleção do maior registro (registro mínimo) de distúrbios a cada vez. A idéia básica é (grande heap superior): 1) Construa a sequência inicial de palavras -chave a ser classificada (R1, R2… .RN) em uma grande pilha superior, que é a área desordenada inicial; 2) troca o elemento superior r [1] com o último elemento R [n] e, em seguida, obtenha uma nova área desordenada (R1, R2,… RN-1) e uma nova região ordenada (RN) e satisfazem r [1,2… n-1] <= r [n]; 3) Como o novo ritmo r [1] após a troca pode violar as propriedades da pilha, é necessário ajustar a área de desordem atual (R1, R2,… Rn-1) a uma nova pilha e depois trocar r [1] com o último elemento da área desordenada novamente para obter uma nova região de distúrbios (R1, R2 ..... Repita esse processo até que o número de elementos na área ordenada seja N-1 e todo o processo de classificação seja concluído. O processo de operação é o seguinte: 1) Inicialize a pilha: Construa r [1..n] como uma pilha; 2) Trocar o elemento superior r [1] da área não ordenada atual com o último registro no intervalo e ajuste a nova área não ordenada em um novo heap. Portanto, para a classificação de heap, as duas operações mais importantes são construir a pilha inicial e ajustar a pilha. De fato, a construção da pilha inicial é na verdade um processo de ajustar a pilha, mas a construção da pilha inicial é ajustar todos os nós que não são de folhas.
Um exemplo de ilustração
Dada uma matriz de modelagem a [] = {16,7,3,20,17,8}, a pilha classifique. Primeiro, construa uma árvore binária completa com base no elemento da matriz e obtenha
Em seguida, você precisa construir a pilha inicial e iniciar o ajuste do último nó não folhas. O processo de ajuste é o seguinte:
Após a troca de 20 e 16, 16 faz com que 16 não atendam às propriedades da pilha, por isso precisa ser reajustado.
Isso dá a pilha inicial.
Quando é ajustado primeiro, torna -se uma grande pilha superior.
Ou seja, cada ajuste é selecionar o maior do nó pai, o nó da criança esquerda e o nó filho direito para trocar com o nó pai (após a troca, o nó infantil que está sendo trocado pode fazer com que o nó infantil seja trocado para não atender à natureza da pilha, para que o nó infantil trocado deve ser ajustado novamente após cada troca). Com a pilha inicial, você pode classificá -lo.
Neste momento, 3 está localizado no topo da pilha e as propriedades não estão cheias da pilha. Você precisa ajustar e continuar a ajustar.
Dessa maneira, todo o intervalo já está em ordem. Do processo acima, podemos ver que a classificação de heap é realmente um tipo de classificação de seleção, uma classificação de seleção de árvores. Mas, para selecionar diretamente o pedido, a fim de selecionar o registro máximo de R [1 ... N], N-1 vezes precisa ser comparado e selecione o registro máximo de R [1 ... N-2], N-2 vezes precisa ser comparado. De fato, muitas dessas comparações N-2 foram feitas nas comparações anteriores do N-1, e a classificação da seleção de árvores usa apenas as características da árvore para salvar alguns dos resultados de comparação anteriores, para que o número de comparações possa ser reduzido. Para as seqüências de palavras -chave n, na pior das hipóteses, cada nó precisa comparar o Log2 (n) Times, para que a complexidade do tempo do pior caso seja o NLOGN. O tipo de heap é instável e não é adequado para classificar com menos registros. Tanto foi descrito acima. Em suma, a prática básica da classificação de heap é: primeiro, use os dados originais para construir uma pilha grande (pequena) como a área não ordenada original e, em seguida, cada vez que o elemento superior da pilha é retirado e colocado na área ordenada. Como o elemento superior da pilha é retirado, colocamos o último elemento na pilha no topo da pilha, de modo que as propriedades da pilha são destruídas. Precisamos reajustar novamente a pilha e continuar n vezes, então n elementos na área não ordenada são colocados na área ordenada e o processo de classificação é concluído.
(A pilha de construção é de baixo para cima)
Aplicação prática:
Na prática, realizamos a classificação de heap para obter o valor máximo ou mínimo sob certas condições. Por exemplo: 10 valores máximos precisam ser encontrados entre 100 números. Portanto, definimos um monte de tamanho 10, criamos os dez primeiros dados em 100 em uma pequena pilha superior (a parte superior da pilha) e, em seguida, comparamos com a parte superior da pilha dos 11º dados em 100 dados. Se a parte superior da pilha for menor que os dados atuais, a parte superior da pilha será exibida, pressione os dados atuais na parte superior da pilha e mova os dados da parte superior da pilha para uma determinada posição.
Código:
classe pública Test0 {static int [] arr; // Array de heap, matriz válida Public test0 (int m) {arr = new int [m];} static int m = 0; static int size = 0; // usado para marcar dados válidos no heap public void addtosmall (int v) {// int [] a = a = a = a = a = {16,4,5,9,1,10,11,12,13,14,15,2,3,6,7,8,111,222,333,555,66,67,54}; // tamanho do phop é 10 // arr = novo int [10]; if (size <arr.length) {arr [size] = v; add_sort (size); // add_sort1 (size); tamanho ++;} else {arr [0] = v; add_sort1 (0);}} public void printsMall () {para (int) i = 0; i <tamanho; i ++) {System.out.println (arr [i]);}} public void del () {size-; arr [0] = arr [9]; add_sort1 (0);} public void pequeno (int (int (int) Índice) {if (m <arr.length) {add_sort (index); m ++;} else {add_sort1 (index); m ++;}} public void add_sort (int index) {// Pequeno Índice 2 * CHIRANHO IND INDENS 1 * INDEX * INDELATO 1 INDELO 1 INDEX * 2 * 2 * 2 * O filho esquerdo*se o último da matriz for par, é a criança certa se o nó infantil for maior que o nó pai, a troca de valores será realizada. O filho direito é maior que o filho esquerdo, a troca de valor é realizada**/int par; if (index! = 0) {if (index%2 == 0) {par = (index-1)/2; if (arr [index] <arr [par]) {swap (arr, index, par); add_sort (par);} se ([index]> dex] <arr [par]) {swap (arr, index, par);} add_sort (par);}} else {par = index/2; if (arr [index] <arr [par]) {swap (Índice, Índice, par); add_sort (par);} if (arr [] <[par*2+1] par*2+1); if (arr [índice] <arr [par]) {swap (arr, index, par);} add_sort (par);}}}} public void add_sort1 (int index) {// ajuste o valor superior de 2 anos/*troca de 1), o valor do índice 2; max = 0; if (esquerda <10 && arr [esquerda] <arr [index]) {max = esquerda;} else {max = index;} if (direita <10 && arr [direita] <arr [max]) {max = direita;} if (max! = index) {swap (arr, max, max); importar java.util.scanner; public class main_test0 {public static void main (string args []) {scanner scan = new scanner (system.in); system.out.println ("(pequeno heap superior), digite o tamanho do heap:"); int m = scan.next (); teste0; {16,4,5,9,1,10,11,12,13,14,15,2,3,6,7,8}; para (int i = 0; i <a.length; i ++) {test.addtoSmall (a [i]);} testsmall (); test.d.del ();O exemplo de classificação de heap java acima (grande monte de primeira linha, pilhagem superior) é todo o conteúdo que eu compartilho com você. Espero que você possa lhe dar uma referência e espero que você possa apoiar mais o wulin.com.