A montón máximo se define como un tipo de La estructura de datos del montón es un tipo de árbol binario que se usa comúnmente en informática para diversos fines, incluida la clasificación, búsqueda y organización de datos.
Introducción a la estructura de datos Max-Heap
Propósito y casos de uso de Max-Heap:
- Cola de prioridad: Uno de los usos principales de la estructura de datos del montón es implementar colas de prioridad.
- Ordenación del montón: La estructura de datos del montón también se utiliza en algoritmos de clasificación.
- Gestión de la memoria: La estructura de datos del montón también se utiliza en la gestión de la memoria. Cuando un programa necesita asignar memoria dinámicamente, utiliza la estructura de datos del montón para realizar un seguimiento de la memoria disponible.
- El algoritmo del camino más corto de Dijkstra utiliza una estructura de datos de montón para realizar un seguimiento de los vértices con la ruta más corta desde el vértice de origen.
Estructura de datos Max-Heap en diferentes idiomas:
1. Montón máximo en C++
Se puede implementar un montón máximo usando el cola_prioridad contenedor de la Biblioteca de plantillas estándar (STL) . El cola_prioridad contenedor es un tipo de adaptador de contenedor que proporciona una forma de almacenar elementos en una estructura de datos similar a una cola en la que cada elemento tiene una prioridad asociada.
Synt ax: priority_queuemaxH;>2. Montón máximo en Java
En Java, se puede implementar un montón máximo usando el Cola de prioridad clase de paquete java.util . La clase PriorityQueue es una cola de prioridad que proporciona una manera de almacenar elementos en una estructura de datos similar a una cola en la que cada elemento tiene una prioridad asociada.
Syntax : PriorityQueue maxHeap= new PriorityQueue(Comparator.reverseOrder());>3. Montón máximo en Python
En Python, se puede implementar un montón máximo usando el montónq módulo, que proporciona funciones para implementar montones. Específicamente, el módulo heapq proporciona una forma de crear y manipular estructuras de datos de montón.
Synt ax: heap = [] heapify(heap)>4. Max-Heap en C#
En C#, se puede implementar un montón máximo usando la clase PriorityQueue del System.Collections.Espacio de nombres genérico . La clase PriorityQueue es una cola de prioridad que proporciona una manera de almacenar elementos en una estructura de datos similar a una cola en la que cada elemento tiene una prioridad asociada.
Syntax: var maxHeap = new PriorityQueue((a, b) =>b-a);>5. Montón máximo en JavaScript
Un montón máximo es un árbol binario donde cada nodo tiene un valor mayor o igual que sus hijos. En JavaScript, puede implementar un montón máximo usando una matriz, donde el primer elemento representa el nodo raíz y los hijos de un nodo en el índice. i están ubicados en índices 2i+1 y 2i+2.
Syntax: const miaxHeap = new MaxHeap();>Diferencia entre montón máximo y mínimo
Montón mínimo Montón máximo 1. En un Min-Heap, la clave presente en el nodo raíz debe ser menor o igual que entre las claves presentes en todos sus hijos. En un Max-Heap, la clave presente en el nodo raíz debe ser mayor o igual que entre las claves presentes en todos sus hijos. 2. En un Min-Heap, el elemento clave mínimo presente en la raíz. En un Max-Heap, el elemento clave máximo presente en la raíz. 3. Un Min-Heap utiliza la prioridad ascendente. Un Max-Heap utiliza la prioridad descendente. 4. En la construcción de un Min-Heap, el elemento más pequeño tiene prioridad. En la construcción de un Max-Heap, el elemento más grande tiene prioridad. 5. En un Min-Heap, el elemento más pequeño es el primero que se extrae del montón. En un Max-Heap, el elemento más grande es el primero que se extrae del montón. Implementación interna de la estructura de datos Max-Heap:
A El montón mínimo normalmente se representa como una matriz .
- El elemento raíz estará en Llegada[0] .
- Para cualquier i-ésimo nodo Arr[yo].
- el niño izquierdo se almacena en el índice 2i+1
- El niño derecho se almacena en el índice. 2i+2
- El padre está almacenado en el piso índice ((i-1)/2)
La implementación interna de Max-Heap requiere 3 pasos principales:
- Inserción : Para insertar un nuevo elemento en el montón, se agrega al final de la matriz y luego se expande hasta que satisface la propiedad del montón.
- Supresión : Para eliminar el elemento máximo (la raíz del montón), el último elemento de la matriz se intercambia con la raíz y la nueva raíz se expande hasta que satisface la propiedad del montón.
- amontonar : Se puede utilizar una operación de almacenamiento dinámico para crear un almacenamiento dinámico máximo a partir de una matriz sin clasificar.
Operaciones sobre la estructura de datos Max-heap y su implementación:
A continuación se muestran algunas operaciones comunes que se pueden realizar en una estructura de datos de estructura de datos de montón,
1. Inserción en estructura de datos Max-Heap :
Los elementos se pueden insertar en el montón siguiendo un enfoque similar al descrito anteriormente para su eliminación. La idea es:
- Primero aumente el tamaño del montón en 1, para que pueda almacenar el nuevo elemento.
- Inserte el nuevo elemento al final del montón.
- Este elemento recién insertado puede distorsionar las propiedades de Heap para sus padres. Entonces, para mantener las propiedades de Heap, apile este elemento recién insertado siguiendo un enfoque ascendente.
Ilustración:
Supongamos que el montón es un montón máximo como:
Inserción en el montón Max
Implementación de la operación de inserción en Max-Heap:
C++
la rueda del mouse no se desplaza correctamente
// C++ program to insert new element to Heap>#include>using>namespace>std;>#define MAX 1000 // Max size of Heap>// Function to heapify ith node in a Heap>// of size n following a Bottom-up approach>void>heapify(>int>arr[],>int>n,>int>i)>{>>// Find parent>>int>parent = (i - 1) / 2;>>if>(arr[parent]>0) {>>// For Max-Heap>>// If current node is greater than its parent>>// Swap both of them and call heapify again>>// for the parent>>if>(arr[i]>arreglo[padre]) {>>swap(arr[i], arr[parent]);>>// Recursively heapify the parent node>>heapify(arr, n, parent);>>}>>}>}>// Function to insert a new node to the Heap>void>insertNode(>int>arr[],>int>& n,>int>Key)>{>>// Increase the size of Heap by 1>>n = n + 1;>>// Insert the element at end of Heap>>arr[n - 1] = Key;>>// Heapify the new node following a>>// Bottom-up approach>>heapify(arr, n, n - 1);>}>// A utility function to print array of size n>void>printArray(>int>arr[],>int>n)>{>>for>(>int>i = 0; i cout << arr[i] << ' '; cout << ' '; } // Driver Code int main() { // Array representation of Max-Heap // 10 // / // 5 3 // / // 2 4 int arr[MAX] = { 10, 5, 3, 2, 4 }; int n = 5; int key = 15; insertNode(arr, n, key); printArray(arr, n); // Final Heap will be: // 15 // / // 5 10 // / / // 2 4 3 return 0; }>>>Java
// Java program for implementing insertion in Heaps>public>class>insertionHeap {>>// Function to heapify ith node in a Heap>>// of size n following a Bottom-up approach>>static>void>heapify(>int>[] arr,>int>n,>int>i)>>{>>// Find parent>>int>parent = (i ->1>) />2>;>>>if>(arr[parent]>>0>) {>>// For Max-Heap>>// If current node is greater than its parent>>// Swap both of them and call heapify again>>// for the parent>>if>(arr[i]>arreglo[padre]) {>>>// swap arr[i] and arr[parent]>>int>temp = arr[i];>>arr[i] = arr[parent];>>arr[parent] = temp;>>>// Recursively heapify the parent node>>heapify(arr, n, parent);>>}>>}>>}>>// Function to insert a new node to the heap.>>static>int>insertNode(>int>[] arr,>int>n,>int>Key)>>{>>// Increase the size of Heap by 1>>n = n +>1>;>>>// Insert the element at end of Heap>>arr[n ->1>] = Key;>>>// Heapify the new node following a>>// Bottom-up approach>>heapify(arr, n, n ->1>);>>>// return new size of Heap>>return>n;>>}>>/* A utility function to print array of size n */>>static>void>printArray(>int>[] arr,>int>n)>>{>>for>(>int>i =>0>; i System.out.println(arr[i] + ' '); System.out.println(); } // Driver Code public static void main(String args[]) { // Array representation of Max-Heap // 10 // / // 5 3 // / // 2 4 // maximum size of the array int MAX = 1000; int[] arr = new int[MAX]; // initializing some values arr[0] = 10; arr[1] = 5; arr[2] = 3; arr[3] = 2; arr[4] = 4; // Current size of the array int n = 5; // the element to be inserted int Key = 15; // The function inserts the new element to the heap and // returns the new size of the array n = insertNode(arr, n, Key); printArray(arr, n); // Final Heap will be: // 15 // / // 5 10 // / / // 2 4 3 } } // The code is contributed by Gautam goel>>>C#
// C# program for implementing insertion in Heaps>using>System;>public>class>insertionHeap {>>// Function to heapify ith node in a Heap of size n following a Bottom-up approach>>static>void>heapify(>int>[] arr,>int>n,>int>i) {>>// Find parent>>int>parent = (i - 1) / 2;>>if>(arr[parent]>0) {>>// For Max-Heap>>// If current node is greater than its parent>>// Swap both of them and call heapify again>>// for the parent>>if>(arr[i]>arreglo[padre]) {>>// swap arr[i] and arr[parent]>>int>temp = arr[i];>>arr[i] = arr[parent];>>arr[parent] = temp;>>// Recursively heapify the parent node>>heapify(arr, n, parent);>>}>>}>>}>>// Function to insert a new node to the heap.>>static>int>insertNode(>int>[] arr,>int>n,>int>Key) {>>// Increase the size of Heap by 1>>n = n + 1;>>// Insert the element at end of Heap>>arr[n - 1] = Key;>>// Heapify the new node following a>>// Bottom-up approach>>heapify(arr, n, n - 1);>>// return new size of Heap>>return>n;>>}>>/* A utility function to print array of size n */>>static>void>printArray(>int>[] arr,>int>n) {>>for>(>int>i = 0; i Console.WriteLine(arr[i] + ' '); Console.WriteLine(''); } public static void Main(string[] args) { // Array representation of Max-Heap // 10 // / // 5 3 // / // 2 4 // maximum size of the array int MAX = 1000; int[] arr = new int[MAX]; // initializing some values arr[0] = 10; arr[1] = 5; arr[2] = 3; arr[3] = 2; arr[4] = 4; // Current size of the array int n = 5; // the element to be inserted int Key = 15; // The function inserts the new element to the heap and // returns the new size of the array n = insertNode(arr, n, Key); printArray(arr, n); // Final Heap will be: // 15 // / // 5 10 // / / // 2 4 3 } } // This code is contributed by ajaymakvana.>>>JavaScript
// Javascript program for implement insertion in Heaps>// To heapify a subtree rooted with node i which is>// an index in arr[].Nn is size of heap>let MAX = 1000;>// Function to heapify ith node in a Heap of size n following a Bottom-up approach>function>heapify(arr, n, i)>{>>// Find parent>>let parent = Math.floor((i-1)/2);>>if>(arr[parent]>= 0) {>>// For Max-Heap>>// If current node is greater than its parent>>// Swap both of them and call heapify again>>// for the parent>>if>(arr[i]>arreglo[padre]) {>>let temp = arr[i];>>arr[i] = arr[parent];>>arr[parent] = temp;>>// Recursively heapify the parent node>>heapify(arr, n, parent);>>}>>}>}>// Function to insert a new node to the Heap>function>insertNode(arr, n, Key)>{>>// Increase the size of Heap by 1>>n = n + 1;>>// Insert the element at end of Heap>>arr[n - 1] = Key;>>// Heapify the new node following a>>// Bottom-up approach>>heapify(arr, n, n - 1);>>>return>n;>}>/* A utility function to print array of size N */>function>printArray(arr, n)>{>>for>(let i = 0; i console.log(arr[i] + ' '); console.log(''); } let arr = [ 10, 5, 3, 2, 4 ]; let n = arr.length; let key = 15; n = insertNode(arr, n, key); printArray(arr, n); // This code is contributed by ajaymakvana>>>Python3
# program to insert new element to Heap># Function to heapify ith node in a Heap># of size n following a Bottom-up approach>def>heapify(arr, n, i):>>parent>=>int>(((i>->1>)>/>2>))>># For Max-Heap>># If current node is greater than its parent>># Swap both of them and call heapify again>># for the parent>>if>arr[parent]>>0>:>>if>arr[i]>arreglo[padre]:>>arr[i], arr[parent]>=>arr[parent], arr[i]>># Recursively heapify the parent node>>heapify(arr, n, parent)># Function to insert a new node to the Heap>def>insertNode(arr, key):>>global>n>># Increase the size of Heap by 1>>n>+>=>1>># Insert the element at end of Heap>>arr.append(key)>># Heapify the new node following a>># Bottom-up approach>>heapify(arr, n, n>->1>)># A utility function to print array of size n>def>printArr(arr, n):>>for>i>in>range>(n):>>print>(arr[i], end>=>' '>)># Driver Code># Array representation of Max-Heap>'''>>10>>/>>5 3>>/>>2 4>'''>arr>=>[>10>,>5>,>3>,>2>,>4>,>1>,>7>]>n>=>7>key>=>15>insertNode(arr, key)>printArr(arr, n)># Final Heap will be:>'''>>15>>/>5 10>/ />2 4 3>Code is written by Rajat Kumar....>'''>>>Producción15 5 10 2 4 3>Complejidad del tiempo: O(log(n)) ( donde n es el número de elementos en el montón )
Espacio Auxiliar: En)2. Eliminación en la estructura de datos Max-Heap :
Eliminar un elemento en cualquier posición intermedia del montón puede resultar costoso, por lo que simplemente podemos reemplazar el elemento que se va a eliminar con el último elemento y eliminar el último elemento del montón.
- Reemplace la raíz o elemento que se eliminará con el último elemento.
- Elimina el último elemento del montón.
- Dado que el último elemento ahora se coloca en la posición del nodo raíz. Por lo tanto, es posible que no siga la propiedad del montón. Por lo tanto, amontone el último nodo colocado en la posición de la raíz.
Ilustración :
Supongamos que el montón es un montón máximo como:
Estructura de datos del montón máximo
El elemento a eliminar es root, es decir 10.
Proceso :
El último elemento es 4.
Paso 1: Reemplace el último elemento con raíz y elimínelo.
Montón máximo
Paso 2 : Amontonar la raíz.
Montón final:
Montón máximo
Implementación de la operación de eliminación en Max-Heap:
C++
// C++ program for implement deletion in Heaps>#include>using>namespace>std;>// To heapify a subtree rooted with node i which is>// an index of arr[] and n is the size of heap>void>heapify(>int>arr[],>int>n,>int>i)>{>>int>largest = i;>// Initialize largest as root>>int>l = 2 * i + 1;>// left = 2*i + 1>>int>r = 2 * i + 2;>// right = 2*i + 2>>// If left child is larger than root>>if>(l arr[largest])>>largest = l;>>// If right child is larger than largest so far>>if>(r arr[largest])>>largest = r;>>// If largest is not root>>if>(largest != i) {>>swap(arr[i], arr[largest]);>>// Recursively heapify the affected sub-tree>>heapify(arr, n, largest);>>}>}>// Function to delete the root from Heap>void>deleteRoot(>int>arr[],>int>& n)>{>>// Get the last element>>int>lastElement = arr[n - 1];>>// Replace root with last element>>arr[0] = lastElement;>>// Decrease size of heap by 1>>n = n - 1;>>// heapify the root node>>heapify(arr, n, 0);>}>/* A utility function to print array of size n */>void>printArray(>int>arr[],>int>n)>{>>for>(>int>i = 0; i cout << arr[i] << ' '; cout << ' '; } // Driver Code int main() { // Array representation of Max-Heap // 10 // / // 5 3 // / // 2 4 int arr[] = { 10, 5, 3, 2, 4 }; int n = sizeof(arr) / sizeof(arr[0]); deleteRoot(arr, n); printArray(arr, n); return 0; }>>>Java
// Java program for implement deletion in Heaps>public>class>deletionHeap {>>// To heapify a subtree rooted with node i which is>>// an index in arr[].Nn is size of heap>>static>void>heapify(>int>arr[],>int>n,>int>i)>>{>>int>largest = i;>// Initialize largest as root>>int>l =>2>* i +>1>;>// left = 2*i + 1>>int>r =>2>* i +>2>;>// right = 2*i + 2>>// If left child is larger than root>>if>(l arr[largest])>>largest = l;>>// If right child is larger than largest so far>>if>(r arr[largest])>>largest = r;>>// If largest is not root>>if>(largest != i) {>>int>swap = arr[i];>>arr[i] = arr[largest];>>arr[largest] = swap;>>// Recursively heapify the affected sub-tree>>heapify(arr, n, largest);>>}>>}>>// Function to delete the root from Heap>>static>int>deleteRoot(>int>arr[],>int>n)>>{>>// Get the last element>>int>lastElement = arr[n ->1>];>>// Replace root with first element>>arr[>0>] = lastElement;>>// Decrease size of heap by 1>>n = n ->1>;>>// heapify the root node>>heapify(arr, n,>0>);>>// return new size of Heap>>return>n;>>}>>/* A utility function to print array of size N */>>static>void>printArray(>int>arr[],>int>n)>>{>>for>(>int>i =>0>; i System.out.print(arr[i] + ' '); System.out.println(); } // Driver Code public static void main(String args[]) { // Array representation of Max-Heap // 10 // / // 5 3 // / // 2 4 int arr[] = { 10, 5, 3, 2, 4 }; int n = arr.length; n = deleteRoot(arr, n); printArray(arr, n); } }>>java int a carbón>C#
// C# program for implement deletion in Heaps>using>System;>public>class>deletionHeap>{>>// To heapify a subtree rooted with node i which is>>// an index in arr[].Nn is size of heap>>static>void>heapify(>int>[]arr,>int>n,>int>i)>>{>>int>largest = i;>// Initialize largest as root>>int>l = 2 * i + 1;>// left = 2*i + 1>>int>r = 2 * i + 2;>// right = 2*i + 2>>// If left child is larger than root>>if>(l arr[largest])>>largest = l;>>// If right child is larger than largest so far>>if>(r arr[largest])>>largest = r;>>// If largest is not root>>if>(largest != i)>>{>>int>swap = arr[i];>>arr[i] = arr[largest];>>arr[largest] = swap;>>// Recursively heapify the affected sub-tree>>heapify(arr, n, largest);>>}>>}>>// Function to delete the root from Heap>>static>int>deleteRoot(>int>[]arr,>int>n)>>{>>// Get the last element>>int>lastElement = arr[n - 1];>>// Replace root with first element>>arr[0] = lastElement;>>// Decrease size of heap by 1>>n = n - 1;>>// heapify the root node>>heapify(arr, n, 0);>>// return new size of Heap>>return>n;>>}>>/* A utility function to print array of size N */>>static>void>printArray(>int>[]arr,>int>n)>>{>>for>(>int>i = 0; i Console.Write(arr[i] + ' '); Console.WriteLine(); } // Driver Code public static void Main() { // Array representation of Max-Heap // 10 // / // 5 3 // / // 2 4 int []arr = { 10, 5, 3, 2, 4 }; int n = arr.Length; n = deleteRoot(arr, n); printArray(arr, n); } } // This code is contributed by Ryuga>>>JavaScript
>>// Javascript program for implement deletion in Heaps>>>// To heapify a subtree rooted with node i which is>>// an index in arr[].Nn is size of heap>>function>heapify(arr, n, i)>>{>>let largest = i;>// Initialize largest as root>>let l = 2 * i + 1;>// left = 2*i + 1>>let r = 2 * i + 2;>// right = 2*i + 2>>// If left child is larger than root>>if>(l arr[largest])>>largest = l;>>// If right child is larger than largest so far>>if>(r arr[largest])>>largest = r;>>// If largest is not root>>if>(largest != i)>>{>>let swap = arr[i];>>arr[i] = arr[largest];>>arr[largest] = swap;>>// Recursively heapify the affected sub-tree>>heapify(arr, n, largest);>>}>>}>>// Function to delete the root from Heap>>function>deleteRoot(arr, n)>>{>>// Get the last element>>let lastElement = arr[n - 1];>>// Replace root with first element>>arr[0] = lastElement;>>// Decrease size of heap by 1>>n = n - 1;>>// heapify the root node>>heapify(arr, n, 0);>>// return new size of Heap>>return>n;>>}>>/* A utility function to print array of size N */>>function>printArray(arr, n)>>{>>for>(let i = 0; i document.write(arr[i] + ' '); document.write(''); } let arr = [ 10, 5, 3, 2, 4 ]; let n = arr.length; n = deleteRoot(arr, n); printArray(arr, n); // This code is contributed by divyeshrabdiya07.>>>Python3
# Python 3 program for implement deletion in Heaps># To heapify a subtree rooted with node i which is># an index of arr[] and n is the size of heap>def>heapify(arr, n, i):>>largest>=>i>#Initialize largest as root>>l>=>2>*>i>+>1># left = 2*i + 1>>r>=>2>*>i>+>2># right = 2*i + 2>>#If left child is larger than root>>if>(l and arr[l]>arr[más grande]): más grande = l #Si el hijo derecho es más grande que el más grande hasta ahora if (r y arr[r]> arr[más grande]): más grande = r # Si más grande no es raíz if (más grande!= i) : arr[i],arr[largest]=arr[largest],arr[i] #Acumular recursivamente el subárbol afectado heapify(arr, n,largest) #Función para eliminar la raíz del Heap def deleteRoot(arr): global n # Obtener el último elemento lastElement = arr[n - 1] # Reemplazar raíz con el último elemento arr[0] = lastElement # Disminuir el tamaño del montón en 1 n = n - 1 # amontonar el nodo raíz heapify(arr, n, 0) # Una función de utilidad para imprimir una matriz de tamaño n def printArray(arr, n): for i in range(n): print(arr[i],end=' ') print() # Código de controlador si __name__ == '__main__': # Representación de matriz de Max-Heap # 10 # / # 5 3 # / # 2 4 arr = [ 10, 5, 3, 2, 4 ] n = len(arr) deleteRoot( arr) printArray(arr, n) # Este código es aportado por Rajat Kumar.>>>Producción5 4 3 2>Complejidad del tiempo : O(log n) donde n es el número de elementos del montón
Espacio Auxiliar: En)3.Operación de vistazo en la estructura de datos Max-heap:
Para acceder al elemento máximo (es decir, la raíz del montón), se devuelve el valor del nodo raíz. La complejidad temporal de mirar en un montón máximo es O (1).
Elemento pico de Max- Heap
Implementación de la operación Peek en Max-Heap:
C++
procesamiento de datos
#include>#include>int>main() {>>// Create a max heap with some elements using a priority_queue>>std::priority_queue<>int>>montón máximo;>>maxHeap.push(9);>>maxHeap.push(8);>>maxHeap.push(7);>>maxHeap.push(6);>>maxHeap.push(5);>>maxHeap.push(4);>>maxHeap.push(3);>>maxHeap.push(2);>>maxHeap.push(1);>>// Get the peak element (i.e., the largest element)>>int>peakElement = maxHeap.top();>>// Print the peak element>>std::cout <<>'Peak element: '><< peakElement << std::endl;>>return>0;>}>>>Java
import>java.util.PriorityQueue;>public>class>GFG {>>public>static>void>main(String[] args) {>>// Create a max heap with some elements using a PriorityQueue>>PriorityQueue maxHeap =>new>PriorityQueue((a, b) ->b-a);>>maxHeap.add(>9>);>>maxHeap.add(>8>);>>maxHeap.add(>7>);>>maxHeap.add(>6>);>>maxHeap.add(>5>);>>maxHeap.add(>4>);>>maxHeap.add(>3>);>>maxHeap.add(>2>);>>maxHeap.add(>1>);>>// Get the peak element (i.e., the largest element)>>int>peakElement = maxHeap.peek();>>// Print the peak element>>System.out.println(>'Peak element: '>+ peakElement);>>}>}>>>C#
using>System;>using>System.Collections.Generic;>public>class>GFG {>>public>static>void>Main() {>>// Create a min heap with some elements using a PriorityQueue>>var>maxHeap =>new>PriorityQueue<>int>>();>>maxHeap.Enqueue(9);>>maxHeap.Enqueue(8);>>maxHeap.Enqueue(7);>>maxHeap.Enqueue(6);>>maxHeap.Enqueue(5);>>maxHeap.Enqueue(4);>>maxHeap.Enqueue(3);>>maxHeap.Enqueue(2);>>maxHeap.Enqueue(1);>>// Get the peak element (i.e., the smallest element)>>int>peakElement = maxHeap.Peek();>>// Print the peak element>>Console.WriteLine(>'Peak element: '>+ peakElement);>>}>}>// Define a PriorityQueue class that uses a max heap>class>PriorityQueue>where>T : IComparable {>>private>List heap;>>public>PriorityQueue() {>>this>.heap =>new>List();>>}>>public>int>Count {>>get>{>return>this>.heap.Count; }>>}>>public>void>Enqueue(T item) {>>this>.heap.Add(item);>>this>.BubbleUp(>this>.heap.Count - 1);>>}>>public>T Dequeue() {>>T item =>this>.heap[0];>>int>lastIndex =>this>.heap.Count - 1;>>this>.heap[0] =>this>.heap[lastIndex];>>this>.heap.RemoveAt(lastIndex);>>this>.BubbleDown(0);>>return>item;>>}>>public>T Peek() {>>return>this>.heap[0];>>}>>private>void>BubbleUp(>int>index) {>>while>(index>0) {>>int>parentIndex = (index - 1) / 2;>>if>(>this>.heap[parentIndex].CompareTo(>this>.heap[index])>= 0) {>>break>;>>}>>Swap(parentIndex, index);>>index = parentIndex;>>}>>}>>private>void>BubbleDown(>int>index) {>>while>(index <>this>.heap.Count) {>>int>leftChildIndex = index * 2 + 1;>>int>rightChildIndex = index * 2 + 2;>>int>largestChildIndex = index;>>if>(leftChildIndex <>this>.heap.Count &&>this>.heap[leftChildIndex].CompareTo(>this>.heap[largestChildIndex])>0) {>>largestChildIndex = leftChildIndex;>>}>>if>(rightChildIndex <>this>.heap.Count &&>this>.heap[rightChildIndex].CompareTo(>this>.heap[largestChildIndex])>0) {>>largestChildIndex = rightChildIndex;>>}>>if>(largestChildIndex == index) {>>break>;>>}>>Swap(largestChildIndex, index);>>index = largestChildIndex;>>}>>}>>private>void>Swap(>int>i,>int>j) {>>T temp =>this>.heap[i];>>this>.heap[i] =>this>.heap[j];>>this>.heap[j] = temp;>>}>}>>>JavaScript
// Define a MaxHeap class that uses an array>class MaxHeap {>>constructor() {>>this>.heap = [];>>}>>push(item) {>>this>.heap.push(item);>>this>.bubbleUp(>this>.heap.length - 1);>>}>>pop() {>>let item =>this>.heap[0];>>let lastIndex =>this>.heap.length - 1;>>this>.heap[0] =>this>.heap[lastIndex];>>this>.heap.pop();>>this>.bubbleDown(0);>>return>item;>>}>>peak() {>>return>this>.heap[0];>>}>>bubbleUp(index) {>>while>(index>0) {>>let parentIndex = Math.floor((index - 1) / 2);>>if>(>this>.heap[parentIndex]>=>this>.heap[index]) {>>break>;>>}>>this>.swap(parentIndex, index);>>index = parentIndex;>>}>>}>>bubbleDown(index) {>>while>(index <>this>.heap.length) {>>let leftChildIndex = index * 2 + 1;>>let rightChildIndex = index * 2 + 2;>>let largestChildIndex = index;>>if>(leftChildIndex <>this>.heap.length &&>this>.heap[leftChildIndex]>>this>.heap[largestChildIndex]) {>>largestChildIndex = leftChildIndex;>>}>>if>(rightChildIndex <>this>.heap.length &&>this>.heap[rightChildIndex]>>this>.heap[largestChildIndex]) {>>largestChildIndex = rightChildIndex;>>}>>if>(largestChildIndex === index) {>>break>;>>}>>this>.swap(largestChildIndex, index);>>index = largestChildIndex;>>}>>}>>swap(i, j) {>>let temp =>this>.heap[i];>>this>.heap[i] =>this>.heap[j];>>this>.heap[j] = temp;>>}>}>// Create a max heap with some elements using an array>let maxHeap =>new>MaxHeap();>maxHeap.push(9);>maxHeap.push(8);>maxHeap.push(7);>maxHeap.push(6);>maxHeap.push(5);>maxHeap.push(4);>maxHeap.push(3);>maxHeap.push(2);>maxHeap.push(1);>// Get the peak element (i.e., the largest element)>let peakElement = maxHeap.peak();>// Print the peak element>console.log(>'Peak element: '>+ peakElement);>>>Python3
import>heapq># Create a max heap with some elements using a list>max_heap>=>[>1>,>2>,>3>,>4>,>5>,>6>,>7>,>8>,>9>]>heapq.heapify(max_heap)># Get the peak element (i.e., the largest element)>peak_element>=>heapq.nlargest(>1>, max_heap)[>0>]># Print the peak element>print>(>'Peak element:'>, peak_element)>>>ProducciónPeak element: 9>Complejidad del tiempo :
- En un montón máximo implementado usando unformacióno una lista, se puede acceder al elemento pico en tiempo constante, O(1), ya que siempre está ubicado en la raíz del montón.
- En un montón máximo implementado usando unárbol binario, también se puede acceder al elemento pico en tiempo O(1), ya que siempre está ubicado en la raíz del árbol.
Espacio Auxiliar: En)
4.Operación Heapify en la estructura de datos Max-heap:
Se puede utilizar una operación heapify para crear un montón máximo a partir de una matriz sin clasificar. Esto se hace comenzando en el último nodo que no es hoja y realizando repetidamente la operación de burbuja hasta que todos los nodos cumplan con la propiedad del montón. La complejidad temporal de heapify en un montón máximo es O (n).
Operaciones de Heapify en Max-Heap
5.Operación de búsqueda en la estructura de datos Max-heap:
Para buscar un elemento en el montón máximo, se puede realizar una búsqueda lineal sobre la matriz que representa el montón. Sin embargo, la complejidad temporal de una búsqueda lineal es O(n), lo que no es eficiente. Por lo tanto, la búsqueda no es una operación comúnmente utilizada en un montón máximo.
Aquí hay un código de ejemplo que muestra cómo buscar un elemento en un montón máximo usando std::buscar() :
C++
#include>#include // for std::priority_queue>using>namespace>std;>int>main() {>>std::priority_queue<>int>>max_heap;>>// example max heap>>>max_heap.push(10);>>max_heap.push(9);>>max_heap.push(8);>>max_heap.push(6);>>max_heap.push(4);>>int>element = 6;>// element to search for>>bool>found =>false>;>>// Copy the max heap to a temporary queue and search for the element>>std::priority_queue<>int>>temperatura = max_heap;>>while>(!temp.empty()) {>>if>(temp.top() == element) {>>found =>true>;>>break>;>>}>>temp.pop();>>}>>if>(found) {>>std::cout <<>'Element found in the max heap.'><< std::endl;>>}>else>{>>std::cout <<>'Element not found in the max heap.'><< std::endl;>>}>>return>0;>}>>>Java
import>java.util.PriorityQueue;>public>class>GFG {>>public>static>void>main(String[] args) {>>PriorityQueue maxHeap =>new>PriorityQueue((a, b) ->b-a);>>maxHeap.add(>3>);>// insert elements into the priority queue>>maxHeap.offer(>1>);>>maxHeap.offer(>4>);>>maxHeap.offer(>1>);>>maxHeap.offer(>6>);>>int>element =>6>;>// element to search for>>boolean>found =>false>;>>// Copy the max heap to a temporary queue and search for the element>>PriorityQueue temp =>new>PriorityQueue(maxHeap);>>while>(!temp.isEmpty()) {>>if>(temp.poll() == element) {>>found =>true>;>>break>;>>}>>}>>if>(found) {>>System.out.println(>'Element found in the max heap.'>);>>}>else>{>>System.out.println(>'Element not found in the max heap.'>);>>}>>}>}>>>C#
using>System;>using>System.Collections.Generic;>class>Program {>>static>void>Main(>string>[] args) {>>// Create a max heap with some elements using a PriorityQueue>>PriorityQueue<>int>>montón máximo =>new>PriorityQueue<>int>>();>>maxHeap.Enqueue(10);>>maxHeap.Enqueue(9);>>maxHeap.Enqueue(8);>>maxHeap.Enqueue(6);>>maxHeap.Enqueue(4);>>int>element = 6;>// element to search for>>bool>found =>false>;>>// Copy the max heap to a temporary queue and search for the element>>PriorityQueue<>int>>temperatura =>new>PriorityQueue<>int>>(maxHeap);>>while>(temp.Count>0) {>>if>(temp.Peek() == element) {>>found =>true>;>>break>;>>}>>temp.Dequeue();>>}>>if>(found) {>>Console.WriteLine(>'Element found in the max heap.'>);>>}>else>{>>Console.WriteLine(>'Element not found in the max heap.'>);>>}>>}>}>// PriorityQueue class>class>PriorityQueue>where>T : IComparable {>>private>List heap =>new>List();>>public>void>Enqueue(T item) {>>heap.Add(item);>>int>child = heap.Count - 1;>>while>(child>0) {>>int>parent = (child - 1) / 2;>>if>(heap[child].CompareTo(heap[parent])>0) {>>T tmp = heap[child];>>heap[child] = heap[parent];>>heap[parent] = tmp;>>child = parent;>>}>else>{>>break>;>>}>>}>>}>>public>T Dequeue() {>>int>last = heap.Count - 1;>>T frontItem = heap[0];>>heap[0] = heap[last];>>heap.RemoveAt(last);>>last--;>>int>parent = 0;>>while>(>true>) {>>int>leftChild = parent * 2 + 1;>>if>(leftChild>último) {>>break>;>>}>>int>rightChild = leftChild + 1;>>if>(rightChild <= last && heap[leftChild].CompareTo(heap[rightChild]) < 0) {>>leftChild = rightChild;>>}>>if>(heap[parent].CompareTo(heap[leftChild]) <0) {>>T tmp = heap[parent];>>heap[parent] = heap[leftChild];>>heap[leftChild] = tmp;>>parent = leftChild;>>}>else>{>>break>;>>}>>}>>return>frontItem;>>}>>public>T Peek() {>>return>heap[0];>>}>>public>int>Count {>>get>{>>return>heap.Count;>>}>>}>}>>>JavaScript
const maxHeap =>new>PriorityQueue((a, b) =>b-a);>maxHeap.add(3);>// insert elements into the priority queue>maxHeap.add(1);>maxHeap.add(4);>maxHeap.add(1);>maxHeap.add(6);>const element = 6;>// element to search for>let found =>false>;>// Copy the max heap to a temporary queue and search for the element>const temp =>new>PriorityQueue(maxHeap);>while>(!temp.isEmpty()) {>if>(temp.poll() === element) {>found =>true>;>break>;>}>}>if>(found) {>console.log(>'Element found in the max heap.'>);>}>else>{>console.log(>'Element not found in the max heap.'>);>}>>>Python3
mapa de árbol
import>heapq>max_heap>=>[>10>,>8>,>7>,>6>,>5>,>3>,>2>,>1>]># example max heap>heapq._heapify_max(max_heap)>element>=>6># element to search for>found>=>False># Copy the max heap to a temporary list and search for the element>temp>=>list>(max_heap)>while>temp:>>if>heapq._heappop_max(temp)>=>=>element:>>found>=>True>>break>if>found:>>print>(>'Element found in the max heap.'>)>else>:>>print>(>'Element not found in the max heap.'>)>>>ProducciónElement found in the max heap.>Complejidad del tiempo : O(n), donde n es el tamaño del montón.
Espacio Auxiliar : En),Aplicaciones de la estructura de datos Max-Heap:
- Algoritmo de clasificación de montón: La estructura de datos del montón es la base del algoritmo de clasificación del montón, que es un algoritmo de clasificación eficiente con una complejidad temporal en el peor de los casos de O (n log n). El algoritmo heapsort se utiliza en diversas aplicaciones, incluida la indexación de bases de datos y el análisis numérico.
- Gestión de la memoria: La estructura de datos del montón se utiliza en los sistemas de administración de memoria para asignar y desasignar memoria dinámicamente. El montón se usa para almacenar los bloques de memoria y la estructura de datos del montón se usa para administrar eficientemente los bloques de memoria y asignarlos a los programas según sea necesario.
- Algoritmos gráficos: La estructura de datos del montón se utiliza en varios algoritmos gráficos, incluidos el algoritmo de Dijkstra, el algoritmo de Prim y el algoritmo de Kruskal. Estos algoritmos requieren una implementación eficiente de la cola de prioridad, que se puede lograr utilizando la estructura de datos del montón.
- Programación de trabajos: La estructura de datos del montón se utiliza en algoritmos de programación de trabajos, donde las tareas se programan según su prioridad o fecha límite. La estructura de datos del montón permite un acceso eficiente a la tarea de mayor prioridad, lo que la convierte en una estructura de datos útil para aplicaciones de programación de trabajos.
Ventajas de la estructura de datos Max-Heap:
- Mantenga eficientemente el valor máximo: Un montón máximo permite el acceso en tiempo constante al elemento máximo del montón, lo que lo hace útil en aplicaciones donde es necesario encontrar el elemento máximo rápidamente.
- Operaciones eficientes de inserción y eliminación: Las operaciones de inserción y eliminación en un montón máximo tienen una complejidad temporal de O (log n), lo que las hace eficientes para grandes colecciones de elementos.
- Colas prioritarias: Se puede utilizar un montón máximo para implementar una cola de prioridad, lo cual es útil en muchas aplicaciones, como programación de trabajos, priorización de tareas y simulación basada en eventos.
- Clasificación: Se puede utilizar un montón máximo para implementar heapsort, que es un algoritmo de clasificación eficiente que tiene una complejidad temporal en el peor de los casos de O (n log n).
- Eficiencia espacial: Un montón máximo se puede implementar como una matriz, lo que requiere menos memoria en comparación con otras estructuras de datos, como un árbol de búsqueda binario o una lista vinculada.
La estructura de datos Max Heap es una herramienta útil y eficiente para mantener y manipular colecciones de elementos, particularmente cuando es necesario acceder rápidamente al elemento máximo o cuando es necesario ordenar o priorizar los elementos.
