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

znak na int v jazyce Java

// 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#

udělat skript spustitelný

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

>

>

java konstanta

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

>

strint do int

>

Výstup

Peak element: 9>

Časová složitost :

• V maximální hromadě implementované pomocí anpolenebo 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í abiná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.