Pila máxima
El montón más grande es que el elemento principal es más grande que el elemento infantil y es un árbol completamente binario.
Los datos [1] comienzan a guardar, los datos [0] están vacíos y no se usan. También puede usar datos [0] como tamaño.
clase pública maxheap <t se extiende comparable <? super t >> {private t [] datos; private int size; private int this.capacity;}/** * @return ver la raíz máxima (solo verlo sin deleción, en comparación con popmax) */public t Seekmax () {return data [1];} public void swap (int i, int j) {if (i! = j) {t temp = data [i]; datos [i] = datos [j]; datos [j] = temp;}}}} {size++;data[size] = item;shiftUp(size);}/** * @return Pop the maximum root (popup means deletion, compared with seekMax) */public T popMax() {swap(1, size--);shiftDown(1);return data[size + 1];}/** * @param child The lower corner mark of the child node is child, and the lower corner table of the parent node is child/2 * / public void shif. max (int a, int b) {if (data [a] .compareto (data [b]) <0) {// if data [b] gran retorno b; // return b} else {// if data [a] big return a; // return a}}/*** @param una marca de la esquina inferior de un elemento en el elemento de datos* @param b esquina inferior marca de un elemento de un elemento de un elemento de la esquina inferior de la esquina* En la matriz de datos*@return return, la marca de esquina inferior de la cual el elemento es grande*/private int max (int a, int b, int c) {int más grande = max (a, b); más grande = max (más grande, c); return más grande;}/***@param Padre La marca de esquina inferior del nodo principal es padre, y las tablas de la esquina inferior de los nodos infantiles izquierdos y el padre son: Padre*2 y el padre*2+1/1*/1/1* Padre) {while (true) {int lChild = padre * 2; // Izquierda niño int rchild = Padre * 2 + 1; // Right Child int Newfather = Padre; // El novato está a punto de ser actualizado. ¿Quién es la marca de la esquina inferior de los nodos de los padres, izquierda y derecha? If (lChild> size) {// Si el nodo padre no tiene ni el hijo izquierdo ni el retorno del niño derecho;} else if (rchild> size) {// Si el nodo padre solo tiene el hijo izquierdo, ningún hijo de niño correcto = max (padre, lchild);} else {// si el nodo padre tiene el niño izquierdo y el niño derecho de neo == Padre) {// Significa que el padre es más grande que ambos nodos infantiles, y el nombre de la tabla ya es un gran montón de raíz, por lo que no es necesario continuar ajustando el retorno;} else {// de lo contrario, debe continuar ajustando el montón hasta que la condición de granado grande se ajuste (padre, novato); // los valores de los valores = neofather; Shiftdown (Newfather)}}} public static void main (string [] args) {// crea un montón raíz grande maxheap <integer> maxheap = nuevo maxheap <integer> (100); // guardar para (int i = 0; i <00; i ++) {maxheap.insert ((int) (int) (math.random () (100); Integer [] arr = new Integer [100]; // elige desde el montón y colóquelo en la matriz para (int i = 0; i <100; i ++) {arr [i] = maxheap.popmax (); system.out.print (arr [i]+"");} system.println ();}}}La función máxima del montón: shiftdown () es diferente de lo anterior
clase pública maxheap <t se extiende comparable <? super t >> {private t [] datos; private int size; private int Elemento; size ++; shiftUp (size);}/** * @return pop max root (emergente medios de deleción, en comparación con Seekmax) */public t popmax () {t retir = data [1]; swap (1, size); size-; shiftdown (1); return ret;}/** * @return ver la raíz máxima (solo vista sin deletion, comparando con pop pop pop); datos [1];} public void swap (int i, int j) {if (i! = j) {t temp = data [i]; data [i] = data [j]; data [j] = temp;}} public void shiftUp (int k) {while (k> 1 && data [k / 2] .compareto (data [k]) <0) {swap (swap (k, k, k / 2); k / = 2); k = = k = = k = = k = = k = = k = = k = = k = = k = = k = = k = = k = = k = = k = = k = = k = = k = = k = = k = = k = = k = = k = = k = = k = = k = = k = = k = = k = = k = = k = k = k = k = k = = k = k = k = k = k = k = k = k = k = k = k = k = k = k = k = k = k = k = k = k = 2) 2;}} public void shiftdown (int padre) {while (2 * padre <= size) {int newfather = 2 * padre; if (newfather + 1 <= size && data [newfather + 1] .compareto (data [newfather])> 0) {// data [j] data [j + 1] el que toma el gran novato = novato + 1;};} (Data [padre] .compareto (data [neowfather])> = 0) {break;} else {swap (padre, newfather); // El valor se intercambia padre = newfather; // newfather is (2*padre) o (2*padre+1), es decir, shiftdown (novato);}}} public void vhatic vhatic principal (string [] string []) {// Maxheap <integer> maxheap = new Maxheap <integer> (100); // guardar para (int i = 0; i <100; i ++) {maxheap.insert ((int) (math.random () * 100));} // crea una matriz intencion 100;Resumir
Lo anterior tiene que ver con el ejemplo del código de almacenamiento máximo de implementación del idioma Java, y espero que sea útil para todos. Los amigos interesados pueden continuar referiéndose a otros temas relacionados en este sitio. Si hay alguna deficiencia, deje un mensaje para señalarlo. ¡Gracias amigos por su apoyo para este sitio!