El programador puede recuperar fácilmente el elemento máximo utilizando el ' Montón máximo ' árbol binario. Como en este árbol, el elemento máximo siempre reside en el nodo superior del árbol que se conoce como el ' raíz ” nodo. Además, ofrece una inserción y eliminación eficiente de elementos mientras mantiene el orden ordenado. Además, un 'Max Heap' puede realizar fácilmente trabajos programados en función de su prioridad u otros criterios.
Este artículo explica el siguiente contenido:
- ¿Cómo usar Max Heap en Java?
- Usa el método “maxHeapify()”
- Usa el método “Collections.reverseOrder()”
¿Cómo usar Max Heap en Java?
A ' Montón máximo ” se utiliza como la estructura de datos subyacente para implementar una cola de prioridad. En la cola de prioridad, los datos se procesan en función de su valor de prioridad asignado. También se puede utilizar para ordenar los elementos de datos en orden descendente de manera eficiente.
El 'Max Heap' se puede generar utilizando dos métodos que se describen a lo largo del ejemplo de códec a continuación:
Método 1: use el método 'maxHeapify ()'
El ' maxHeapify() El método ” genera un “ Montón máximo ” a partir de una colección existente de elementos mediante la transformación de estructuras de datos. Además, este método ayuda a modificar la matriz original en su lugar, lo que reduce la necesidad de memoria adicional.
Por ejemplo, visite el siguiente código para generar un ' Montón máximo ” usando el método “maxHeapify()”:
importar java.util.ArrayList;importar java.util.Collections;
importar java.util.List;
clase pública MaxHeapifyExam {
vacío público estático principal ( Cadena [ ] argumentos ) // creación de principal ( ) método
{
Lista < Entero > testsEle = nueva lista de matrices <> ( ) ;
testEle.añadir ( 5 ) ;
testEle.añadir ( 3 ) ;
testEle.añadir ( 8 ) ;
testEle.añadir ( 2 ) ;
testEle.añadir ( 1 ) ;
testEle.añadir ( 7 ) ;
Sistema.fuera.println ( 'Lista original:' + pruebasEle ) ;
maxHeapificar ( PRUEBAS ) ;
Sistema.fuera.println ( 'El montón máximo generado:' + pruebasEle ) ;
}
vacío estático privado maxHeapify ( Lista < Entero > PRUEBAS ) {
int k = testEle.tamaño ( ) ;
para ( int yo = k / 2 - 1 ; i > = 0 ; i-- ) {
amontonar ( pruebasEle, k, i ) ;
}
}
montón de vacío estático privado ( Lista < Entero > pruebasEle, int k, int i ) {
int mayor = i;
int lado izquierdo = 2 * yo + 1 ;
int lado derecho = 2 * yo + 2 ;
si ( lado izquierdo < k && testEle.obtener ( lado izquierdo ) > testEle.obtener ( mayor que ) ) {
mayor = lado izquierdo;
}
si ( lado derecho < k && testEle.obtener ( lado derecho ) > testEle.obtener ( mayor que ) ) {
mayor = lado derecho;
}
si ( mayor que ! = yo ) {
Colecciones.swap ( testsEle, i, mayor ) ;
amontonar ( testsEle, k, mayor ) ;
}
}
}
Explicación del código anterior:
- Primero, la lista “ PRUEBAS ” se inicializa con elementos de datos ficticios en el “ principal() ” e impreso en la consola.
- A continuación, la lista 'testEle' se pasa a la función 'maxHeapify()', y luego la lista devuelta se muestra en la consola.
- Entonces el ' maxHeapify() El método ' se inicializa y el tamaño de la lista proporcionada se recupera utilizando el ' tamaño() ' método.
- A continuación, utilice el ' para ” bucle para establecer la estructura del montón y calcular la posición de cada nodo.
- Ahora, usa el ' amontonar() y establezca la posición de los nodos 'superior', 'izquierdo' y 'derecho' asignando valores a las variables 'mayor', 'lado izquierdo' y 'lado derecho', respectivamente.
- Después de eso, utilice múltiples ' si ” sentencias condicionales para verificar si el “ lado izquierdo El nodo ” es más grande que el “ lado derecho ” nodo y viceversa. Al final, el valor más grande se almacena en el ' mayor que ” nodo.
- Finalmente, el nuevo “ mayor que El valor del nodo ” se verifica con el valor ya almacenado en el “ mayor que ” variable de nodo. Y el ' intercambio() La función ” funciona en consecuencia para establecer el valor más grande en el “ mayor que ' variable.
Después del final de la fase de ejecución:
La instantánea muestra que el montón máximo se genera usando el ' maxHeapify() ” método en Java.
Método 2: use el método 'Collections.reverseOrder ()'
El ' Colecciones.reverseOrder() ” ofrece un método simple y conciso para generar un “ Montón máximo ” ordenando la colección en orden inverso. Esto permite que el código se reutilice y evita la necesidad de implementar la costumbre “ amontonar ”, como se muestra en el siguiente fragmento de código:
importar java.util.ArrayList;importar java.util.Collections;
importar java.util.List;
ejemplo de orden inverso de clase pública {
vacío público estático principal ( Cadena [ ] argumentos ) // creación de principal ( ) método
{
Lista < Entero > testsEle = nueva lista de matrices <> ( ) ;
testEle.añadir ( 5 ) ;
testEle.añadir ( 38 ) ;
testEle.añadir ( 98 ) ;
testEle.añadir ( 26 ) ;
testEle.añadir ( 1 ) ;
testEle.añadir ( 73 ) ;
Sistema.fuera.println ( 'Lista original:' + pruebasEle ) ;
Colecciones.clasificar ( testsEle, Colecciones.reverseOrder ( ) ) ;
Sistema.fuera.println ( 'El montón máximo generado:' + pruebasEle ) ;
}
}
Explicación del código anterior:
- Primero, importe el “ Lista de arreglo ”, “ Colecciones ' y ' Lista ” utilidades en el archivo Java.
- Luego, crea un “ Lista ' llamado ' PRUEBAS ” e inserte elementos ficticios en la lista.
- A continuación, el “ clasificar() El método ” se utiliza para ordenar los elementos de datos en orden ascendente y pasar la lista como un parámetro a lo largo del “ Colecciones.reverseOrder() ' método. Esto hace que la clasificación de los “ PRUEBAS ” lista en orden inverso.
Después del final de la fase de ejecución:
La instantánea muestra que 'Max Heap' se genera y ordena mediante el método 'Collections.reverseOrder()'.
Conclusión
Al crear un “ Montón máximo ”, los usuarios pueden utilizar los métodos “maxHeapify()” y “Collections.reverseOrder()”. Gestionan una colección de elementos de una manera que permite un acceso rápido al elemento máximo y un mantenimiento eficiente de un orden ordenado. Depende únicamente de los requisitos específicos y el nivel de control necesario sobre el proceso de creación del montón.