A Max-Hroma je definován jako typ Struktura dat haldy je typ binárního stromu, který se běžně používá v informatice pro různé účely, včetně třídění, vyhledávání a organizování dat.

Úvod do datové struktury Max-Heap

Účel a případy použití Max-Heap:

• Prioritní fronta: Jedním z primárních použití datové struktury haldy je implementace prioritních front.
• Řazení haldy: Struktura dat haldy se také používá v třídicích algoritmech.
• Správa paměti: Struktura dat haldy se také používá při správě paměti. Když program potřebuje dynamicky alokovat paměť, používá datovou strukturu haldy ke sledování dostupné paměti.
• Dijkstrův algoritmus nejkratší cesty používá datovou strukturu haldy ke sledování vrcholů s nejkratší cestou ze zdrojového vrcholu.

Struktura dat Max-Heap v různých jazycích:

1. Max-Heap v C++

Maximální haldu lze implementovat pomocí prioritní_fronta kontejner z Standardní knihovna šablon (STL) . The priorita_fronta kontejner je typ adaptéru kontejneru, který poskytuje způsob ukládání prvků do datové struktury podobné frontě, ve které má každý prvek přiřazenou prioritu.

  Synt  ax: priority_queuemaxH; 

2. Max-Heap v Javě

V Javě lze maximální haldu implementovat pomocí PriorityQueue třídy od balíček java.util . Třída PriorityQueue je prioritní fronta, která poskytuje způsob ukládání prvků do datové struktury podobné frontě, ve které má každý prvek přiřazenou prioritu.

  Syntax  : PriorityQueue maxHeap= new PriorityQueue(Comparator.reverseOrder()); 

3. Max-Heap v Pythonu

V Pythonu lze maximální haldu implementovat pomocí heapq modul, který poskytuje funkce pro implementaci hald. Konkrétně modul heapq poskytuje způsob, jak vytvářet a manipulovat s datovými strukturami haldy.

  Synt  ax: heap = []  heapify(heap) 

4. Max-Heap v C#

V C# lze maximální haldu implementovat pomocí třídy PriorityQueue z System.Collections.Generic namespace . Třída PriorityQueue je prioritní fronta, která poskytuje způsob ukládání prvků do datové struktury podobné frontě, ve které má každý prvek přiřazenou prioritu.

  Syntax:   var maxHeap = new PriorityQueue((a, b) =>b - a); 

5. Max-Heap v JavaScriptu

Maximální halda je binární strom, kde každý uzel má hodnotu větší nebo rovnou jeho potomkům. V JavaScriptu můžete implementovat maximální haldu pomocí pole, kde první prvek představuje kořenový uzel a potomci uzlu na indexu i se nacházejí na indexech 2i+1 a 2i+2.

Syntax: const miaxHeap = new MaxHeap(); 

Rozdíl mezi maximální a minimální haldou

	Min. halda	Max Heap
1.	V Min-Heap musí být klíč přítomný v kořenovém uzlu menší nebo roven mezi klíči přítomnými u všech jeho potomků.	V Max-Heap musí být klíč přítomný v kořenovém uzlu větší nebo roven mezi klíči přítomnými u všech jeho potomků.
2.	V Min-Heap minimální klíčový prvek přítomný v kořenu.	V Max-Heap maximální klíčový prvek přítomný v kořenovém adresáři.
3.	Min-Heap používá vzestupnou prioritu.	Max-Heap používá sestupnou prioritu.
4.	Při konstrukci min-hromady má přednost nejmenší prvek.	Při konstrukci Max-Heap má největší prvek přednost.
5.	V Min-Heap je nejmenší prvek první, který je vytažen z hromady.	V Max-Heap je největší prvek první, který je vytažen z hromady.

Interní implementace datové struktury Max-Heap:

A Minimální halda je obvykle reprezentována jako pole .

• Kořenový prvek bude v Arr[0] .
• Pro jakýkoli i-tý uzel Arr[i].
  • levé dítě je uloženo v indexu 2i+1
  • Pravé dítě je uloženo v indexu 2i+2
  • Rodič je uložen v indexovém patře ((i-1)/2)

Interní implementace Max-Heap vyžaduje 3 hlavní kroky:

1. Vložení : Chcete-li vložit nový prvek do haldy, je přidán na konec pole a poté probubláván, dokud nesplňuje vlastnost haldy.
2. Vymazání : Chcete-li odstranit maximální prvek (kořen haldy), poslední prvek v poli se zamění s kořenem a nový kořen se probublává, dokud nesplňuje vlastnost haldy.
3. Heapify : Operaci heapify lze použít k vytvoření maximální haldy z netříděného pole.

Operace na datové struktuře Max-heap a jejich implementace:

Zde jsou některé běžné operace, které lze provádět s datovou strukturou datové struktury haldy,

1. Vložení do datové struktury Max-Heap :

Prvky mohou být vkládány do hromady podobným postupem, jaký byl popsán výše pro mazání. Cílem je:

• Nejprve zvětšete velikost haldy o 1, aby bylo možné uložit nový prvek.
• Vložte nový prvek na konec haldy.
• Tento nově vložený prvek může narušit vlastnosti haldy pro její rodiče. Chcete-li tedy zachovat vlastnosti haldy, navršte tento nově vložený prvek postupem zdola nahoru.

Ilustrace:

Předpokládejme, že halda je maximální halda jako:

Vložení do maximální haldy

Implementace operace vkládání v Max-Heap:

C++

// 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]>arr[rodič]) {> > 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; }>

Jáva

// 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]>arr[rodič]) {> > > // 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]>arr[rodič]) {> > // 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]>arr[rodič]) {> > 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]>arr[rodič]:> > 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....> '''>

Výstup

15 5 10 2 4 3 

Časová složitost: O(log(n)) ( kde n je číslo prvků v hromadě )
Pomocný prostor: Na)

2. Odstranění v datové struktuře Max-Heap :

Odstranění prvku na jakékoli mezilehlé pozici v hromadě může být nákladné, takže můžeme jednoduše nahradit prvek, který má být odstraněn, posledním prvkem a smazat poslední prvek hromady.

• Nahraďte kořen nebo prvek, který chcete odstranit, posledním prvkem.
• Odstraňte poslední prvek z haldy.
• Protože poslední prvek je nyní umístěn na pozici kořenového uzlu. Nemusí se tedy řídit vlastností haldy. Proto navraťte poslední uzel umístěný na pozici kořene.

Ilustrace :

Předpokládejme, že halda je maximální halda jako:

Maximální datová struktura haldy

Prvek, který má být odstraněn, je root, tedy 10.

Proces :

Posledním prvkem je 4.

Krok 1: Nahraďte poslední prvek rootem a odstraňte jej.

Max Heap

Krok 2 : Heapify root.

Konečná hromada:

Max Heap

Implementace operace mazání v 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; }>

Jáva

// 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); } }>

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[největší]): největší = l #Pokud je pravý potomek větší než dosud největší if (r a arr[r]> arr[největší]): největší = r # Pokud největší není kořen if (největší != i) : arr[i],arr[největší]=arr[největší],arr[i] #Rekurzivně heapify postižený podstrom heapify(arr, n, největší) #Funkce pro odstranění kořene z haldy def deleteRoot(arr): global n # Získat poslední prvek lastElement = arr[n - 1] # Nahradit kořen posledním prvkem arr[0] = lastElement # Zmenšit velikost haldy o 1 n = n - 1 # heapify kořenový uzel heapify(arr, n, 0) # Obslužná funkce pro tisk pole o velikosti n def printArray(arr, n): pro i v rozsahu (n): print(arr[i],end=' ') print() # Kód ovladače, pokud __name__ == '__main__': # Reprezentace pole Max-Heap # 10 # / # 5 3 # / # 2 4 arr = [ 10, 5, 3, 2, 4 ] n = len(arr) deleteRoot( arr) printArray(arr, n) # Tento kód přispěl Rajat Kumar.>

Výstup

5 4 3 2 

Časová složitost : O(log n) kde n je číslo prvků v haldě
Pomocný prostor: Na)

3. Operace náhledu na datové struktuře Max-heap:

Pro přístup k maximálnímu prvku (tj. kořeni haldy) je vrácena hodnota kořenového uzlu. Časová složitost náhledu v maximální hromadě je O(1).

Vrcholový Prvek Max-Hromy

Implementace operace Peek v Max-Heap:

C++

#include> #include> int> main() {> > // Create a max heap with some elements using a priority_queue> > std::priority_queue <> int> >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)> > int> peakElement = maxHeap.top();> > // Print the peak element> > std::cout < <> 'Peak element: '> < < peakElement < < std::endl;> > return> 0;> }>

Jáva

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)>

Výstup

Peak element: 9 

Časová složitost :

• V maximální hromadě implementované pomocí an pole nebo seznam, může být vrcholový prvek přístupný v konstantním čase, O(1), protože je vždy umístěn v kořenu haldy.
• V maximální hromadě implementované pomocí a binární strom , k vrcholovému prvku lze také přistupovat v čase O(1), protože je vždy umístěn v kořeni stromu.

Pomocný prostor: Na)

4. Operace heapify na datové struktuře Max-heap :

Operaci heapify lze použít k vytvoření maximální haldy z neseřazeného pole. To se provádí tak, že se začne od posledního nelistového uzlu a opakovaně se provádí operace bublina dolů, dokud všechny uzly nesplní vlastnost haldy. Časová složitost heapify v maximální hromadě je O(n).

Operace Heapify v Max-Heap

5. Operace vyhledávání na datové struktuře Max-heap :

Chcete-li vyhledat prvek v maximální hromadě, lze provést lineární vyhledávání v poli, které představuje hromadu. Časová složitost lineárního vyhledávání je však O(n), což není efektivní. Hledání proto není běžně používaná operace v maximální hromadě.

Zde je příklad kódu, který ukazuje, jak hledat prvek v maximální hromadě pomocí std::najít() :

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> >temp = 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;> }>

Jáva

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> >maxHeap => 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> >teplota => 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>poslední) {> > 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

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.'> )>

Výstup

Element found in the max heap. 

Časová složitost : O(n), kde n je velikost haldy.
Pomocný prostor : O(n),

Aplikace datové struktury Max-Heap:

• Algoritmus Heapsort: Struktura dat haldy je základem pro algoritmus heapsort, což je účinný třídicí algoritmus s časovou složitostí nejhoršího případu O(n log n). Algoritmus heapsort se používá v různých aplikacích, včetně indexování databáze a numerické analýzy.
• Správa paměti: Datová struktura haldy se používá v systémech správy paměti k dynamickému alokaci a uvolnění paměti. Halda se používá k ukládání paměťových bloků a datová struktura haldy se používá k efektivní správě paměťových bloků a jejich přidělování programům podle potřeby.
• Algoritmy grafů: Struktura dat haldy se používá v různých grafových algoritmech, včetně Dijkstrova algoritmu, Primova algoritmu a Kruskalova algoritmu. Tyto algoritmy vyžadují efektivní implementaci prioritní fronty, které lze dosáhnout pomocí datové struktury haldy.
• Plánování práce: Struktura dat haldy se používá v algoritmech plánování úloh, kde jsou úkoly plánovány na základě jejich priority nebo termínu. Struktura dat haldy umožňuje efektivní přístup k úloze s nejvyšší prioritou, což z ní činí užitečnou datovou strukturu pro aplikace pro plánování úloh.

Výhody datové struktury Max-Heap:

• Efektivně udržujte maximální hodnotu: Maximální halda umožňuje neustálý přístup k maximálnímu prvku v haldě, což je užitečné v aplikacích, kde je potřeba rychle najít maximální prvek.
• Efektivní operace vkládání a odstraňování: Operace vložení a odstranění v maximální haldě mají časovou složitost O(log n), což je činí efektivními pro velké kolekce prvků.
• Prioritní fronty: Maximální haldu lze použít k implementaci prioritní fronty, což je užitečné v mnoha aplikacích, jako je plánování úloh, prioritizace úloh a simulace řízená událostmi.
• řazení: Maximální haldu lze použít k implementaci heapsortu, což je účinný třídicí algoritmus, který má v nejhorším případě časovou složitost O(n log n).
• Prostorová efektivita: Maximální haldu lze implementovat jako pole, které vyžaduje méně paměti ve srovnání s jinými datovými strukturami, jako je binární vyhledávací strom nebo propojený seznam.

Struktura dat maximální haldy je užitečným a efektivním nástrojem pro údržbu a manipulaci s kolekcemi prvků, zejména když je třeba rychle získat přístup k maximálnímu prvku nebo když je třeba prvky seřadit nebo upřednostnit.