A Max-Heap ir definēts kā veids Kaudzes datu struktūra ir bināra koka veids, ko datorzinātnēs parasti izmanto dažādiem mērķiem, tostarp datu kārtošanai, meklēšanai un kārtošanai.
Ievads Max-Heap datu struktūrā
Max-Heap mērķis un lietošanas gadījumi:
- Prioritātes rinda: Viens no primārajiem kaudzes datu struktūras lietojumiem ir prioritāro rindu ieviešana.
- Kaudzes kārtošana: Kaudzes datu struktūra tiek izmantota arī šķirošanas algoritmos.
- Atmiņas pārvaldība: Kaudzes datu struktūra tiek izmantota arī atmiņas pārvaldībā. Kad programmai ir dinamiski jāpiešķir atmiņa, tā izmanto kaudzes datu struktūru, lai sekotu līdzi pieejamajai atmiņai.
- Dijkstra īsākā ceļa algoritms izmanto kaudzes datu struktūru, lai izsekotu virsotnēm ar īsāko ceļu no avota virsotnes.
Max-Heap datu struktūra dažādās valodās:
1. Max-Heap valodā C++
Maksimālo kaudzi var ieviest, izmantojot prioritāte_rinda konteiners no Standarta veidņu bibliotēka (STL) . The prioritāte_rinda konteiners ir konteinera adaptera veids, kas nodrošina veidu, kā saglabāt elementus rindai līdzīgā datu struktūrā, kurā katram elementam ir ar to saistīta prioritāte.
Synt ax: priority_queuemaxH;>2. Max-Heap Java
Java programmā maksimālo kaudzi var ieviest, izmantojot PriorityQueue klase no java.util pakotne . PriorityQueue klase ir prioritāra rinda, kas nodrošina veidu, kā saglabāt elementus rindai līdzīgā datu struktūrā, kurā katram elementam ir ar to saistīta prioritāte.
Syntax : PriorityQueue maxHeap= new PriorityQueue(Comparator.reverseOrder());>3. Max-Heap programmā Python
Programmā Python maksimālo kaudzi var ieviest, izmantojot kaudze q modulis, kas nodrošina kaudžu ieviešanas funkcijas. Konkrēti, heapq modulis nodrošina veidu, kā izveidot un manipulēt ar kaudzes datu struktūrām.
Synt ax: heap = [] heapify(heap)>4. Max-Heap C#
C# valodā maksimālo kaudzi var ieviest, izmantojot PriorityQueue klasi no System.Collections.Generic namespace . PriorityQueue klase ir prioritāra rinda, kas nodrošina veidu, kā saglabāt elementus rindai līdzīgā datu struktūrā, kurā katram elementam ir ar to saistīta prioritāte.
Syntax: var maxHeap = new PriorityQueue((a, b) =>ba);>>5. Max-Heap JavaScript
Maksimālā kaudze ir binārs koks, kurā katram mezglam ir vērtība, kas ir lielāka vai vienāda ar tā bērniem. Programmā JavaScript varat ieviest maksimālo kaudzi, izmantojot masīvu, kur pirmais elements apzīmē saknes mezglu un mezgla atvases indeksā. i atrodas pie indeksiem 2i+1 un 2i+2.
Atšķirība starp Max un Min Heap
Minimālā kaudze Max Heap 1. Min-Heap atslēgai, kas atrodas saknes mezglā, ir jābūt mazākai vai vienādai ar to atslēgām, kas atrodas visos tā atvasumos. Max-Heap atslēgai, kas atrodas saknes mezglā, ir jābūt lielākai vai vienādai ar atslēgām, kas atrodas visos tā atslēgpunktos. 2. Min-Heap minimālais galvenais elements, kas atrodas saknē. Max-Heap maksimālais galvenais elements, kas atrodas saknē. 3. Min-Heap izmanto augošu prioritāti. Max-Heap izmanto dilstošo prioritāti. 4. Min-Heap konstrukcijā mazākajam elementam ir prioritāte. Max-Heap konstrukcijā lielākajam elementam ir prioritāte. 5. Min-Heap mazākais elements ir pirmais, kas tiek izmests no kaudzes. Max-Heap lielākais elements ir pirmais, kas tiek izmests no kaudzes. Max-Heap datu struktūras iekšējā ieviešana:
A Minimālā kaudze parasti tiek attēlota kā masīvs .
- Saknes elements būs plkst Arr[0] .
- Jebkuram itajam mezglam Arr[i].
- kreisais bērns tiek saglabāts rādītājā 2i+1
- Labais bērns tiek saglabāts rādītājā 2i+2
- Vecāki tiek glabāti indeksa stāvā ((i-1)/2)
Max-Heap iekšējai ieviešanai ir nepieciešami 3 galvenie soļi:
- Ievietošana : lai kaudzē ievietotu jaunu elementu, tas tiek pievienots masīva beigām un pēc tam tiek burbuļots, līdz tas atbilst kaudzes īpašībai.
- Dzēšana : lai dzēstu maksimālo elementu (kaudzes sakni), pēdējais masīva elements tiek apmainīts ar sakni, un jaunais saknes elements tiek izspiests uz leju, līdz tas atbilst kaudzes īpašībai.
- Veidot kaudzi : kaudzes veidošanas darbību var izmantot, lai izveidotu maksimālo kaudzi no nešķirota masīva.
Operācijas ar Max-heap datu struktūru un to ieviešana:
Šeit ir dažas izplatītas darbības, kuras var veikt kaudzes datu struktūras datu struktūrā,
1. Ievietošana Max-Heap datu struktūrā :
Elementus var ievietot kaudzē, izmantojot līdzīgu pieeju, kā iepriekš aprakstīts dzēšanai. Ideja ir:
- Vispirms palieliniet kaudzes izmēru par 1, lai tajā varētu saglabāt jauno elementu.
- Ievietojiet jauno elementu kaudzes galā.
- Šis tikko ievietotais elements var izkropļot Heap īpašības tā vecākiem. Tāpēc, lai saglabātu kaudzes īpašības, palieliniet šo tikko ievietoto elementu, izmantojot augšupēju pieeju.
Ilustrācija:
Pieņemsim, ka kaudze ir maksimālā kaudze, kā:
Ievietošana Max kaudzē
Ievietošanas operācijas ieviešana Max-Heap:
C++
atzvanīšanas ellē javascript
// 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[vecāks]) {>>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]>>>) {> >// 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[vecāks]) {>>>// 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[vecāks]) {>>// 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[vecāks]) {>>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]>>>:> >if>arr[i]>arr[vecāks]:>>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....>'''>>>Izvade15 5 10 2 4 3>Laika sarežģītība: O(log(n)) ( kur n ir kaudzes elementu skaits )
Palīgtelpa: O(n)2. Dzēšana Max-Heap datu struktūrā :
Elementa dzēšana jebkurā kaudzē starpposmā var būt dārga, tāpēc mēs varam vienkārši aizstāt dzēšamo elementu ar pēdējo elementu un dzēst pēdējo kaudzes elementu.
- Aizstāt sakni vai elementu, kas jādzēš, ar pēdējo elementu.
- Izdzēsiet pēdējo elementu no kaudzes.
- Tā kā pēdējais elements tagad ir novietots saknes mezgla pozīcijā. Tātad tas var neatbilst kaudzes rekvizītam. Tāpēc salieciet pēdējo mezglu, kas novietots saknes vietā.
Ilustrācija :
Pieņemsim, ka kaudze ir maksimālā kaudze, kā:
Maksimālā kaudzes datu struktūra
Elements, kas jāizdzēš, ir root, t.i., 10.
Process :
Pēdējais elements ir 4.
1. darbība: Aizstājiet pēdējo elementu ar sakni un izdzēsiet to.
Max Heap
2. darbība : Palielināt sakni.
Pēdējā kaudze:
Max Heap
Dzēšanas operācijas ieviešana 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); } }>>>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.>>t ff>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[lielākais]): lielākais = l #Ja labais bērns ir lielāks par līdz šim lielāko if (r un arr[r]> arr[lielākais]): lielākais = r # Ja lielākais nav sakne if (lielākais != i) : arr[i],arr[lielākais]=arr[lielākais],arr[i] #Rekursīvi veidot ietekmēto apakškoku kaudzi heapify(arr, n, lielākais) #Funkcija saknes dzēšanai no kaudzes def deleteRoot(arr): globāls n # Iegūt pēdējo elementu lastElement = arr[n - 1] # Aizstāt sakni ar pēdējo elementu arr[0] = lastElement # Samazināt kaudzes izmēru par 1 n = n - 1 # izveidot saknes mezglu kaudzi heapify(arr, n, 0) # Lietderības funkcija n izmēra masīva drukāšanai def printArray(arr, n): priekš i diapazonā(n): print(arr[i],end=' ') print() # Draivera kods, ja __name__ == '__main__': # Max-Heap masīva attēlojums # 10 # / # 5 3 # / # 2 4 arr = [ 10, 5, 3, 2, 4 ] n = len(arr) deleteRoot( arr) printArray(arr, n) # Šo kodu ir sagatavojis Rajats Kumars.>>>5 4 3 2> Laika sarežģītība : O(log n), kur n ir kaudzes elementu skaits
Palīgtelpa: O(n)3.Ielūkošanās darbība Max-heap datu struktūrā:
Lai piekļūtu maksimālajam elementam (t.i., kaudzes saknei), tiek atgriezta saknes mezgla vērtība. Maksimālā kaudzes skatīšanās laika sarežģītība ir O(1).
Maksimālais elements Max-Heap
Peek operācijas ieviešana 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
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]>>>.heap[largestChildIndex]) {> >largestChildIndex = leftChildIndex;>>}>>if>(rightChildIndex <>this>.heap.length &&>this>.heap[rightChildIndex]>>>.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
java sveiki pasaule
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)>>>IzvadePeak element: 9>Laika sarežģītība :
- Maksimālā kaudzē, kas ieviesta, izmantojot anmasīvsvai sarakstu, pīķa elementam var piekļūt konstantā laikā O(1), jo tas vienmēr atrodas kaudzes saknē.
- Maksimālā kaudzē, kas ieviesta, izmantojot abinārais koks, pīķa elementam var piekļūt arī O(1) laikā, jo tas vienmēr atrodas koka saknē.
Palīgtelpa: O(n)
4.Heapify operācija Max-heap datu struktūrā:
Lai izveidotu maksimālo kaudzi no nešķirota masīva, var izmantot kaudzes palielināšanas darbību. Tas tiek darīts, sākot no pēdējā mezgla, kas nav lapas, un atkārtoti veicot burbuļu lejupvērsšanas darbību, līdz visi mezgli atbilst kaudzes īpašībai. Maksimālā kaudzes kaudzes laika sarežģītība ir O(n).
Heapify operācijas Max-Heap
5.Meklēšanas darbība Max-heap datu struktūrā:
Lai meklētu elementu maksimālajā kaudzē, var veikt lineāru meklēšanu masīvā, kas attēlo kaudzi. Tomēr lineārās meklēšanas laika sarežģītība ir O (n), kas nav efektīva. Tāpēc meklēšana nav bieži izmantota darbība maksimālā kaudzē.
Šeit ir koda piemērs, kas parāda, kā meklēt elementu maksimālajā kaudzē, izmantojot std::find() :
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;>}>>>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#
javascript globālie mainīgie
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>>temp =>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>pēdējais) {>>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.'>)>>>IzvadeElement found in the max heap.>Laika sarežģītība : O(n), kur n ir kaudzes izmērs.
Palīgtelpa : O(n),Max-Heap datu struktūras pielietojumi:
- Kaudzes kārtošanas algoritms: Kaudzes datu struktūra ir pamats kaudzes kārtošanas algoritmam, kas ir efektīvs kārtošanas algoritms ar sliktākā gadījuma laika sarežģītību O(n log n). Kaudzes kārtošanas algoritms tiek izmantots dažādās lietojumprogrammās, tostarp datu bāzes indeksēšanā un skaitliskā analīzē.
- Atmiņas pārvaldība: Kaudzes datu struktūra tiek izmantota atmiņas pārvaldības sistēmās, lai dinamiski piešķirtu un atdalītu atmiņu. Kaudze tiek izmantota atmiņas bloku glabāšanai, un kaudzes datu struktūra tiek izmantota, lai efektīvi pārvaldītu atmiņas blokus un pēc vajadzības piešķirtu tos programmām.
- Grafiku algoritmi: Kaudzes datu struktūra tiek izmantota dažādos grafiku algoritmos, tostarp Dijkstra algoritmā, Prima algoritmā un Kruskal algoritmā. Šie algoritmi prasa efektīvu prioritāšu rindu ieviešanu, ko var panākt, izmantojot kaudzes datu struktūru.
- Darba grafiks: Kaudzes datu struktūra tiek izmantota darbu plānošanas algoritmos, kur uzdevumi tiek ieplānoti, pamatojoties uz to prioritāti vai termiņu. Kaudzes datu struktūra ļauj efektīvi piekļūt augstākās prioritātes uzdevumam, padarot to par noderīgu datu struktūru darbu plānošanas lietojumprogrammām.
Max-Heap datu struktūras priekšrocības:
- Efektīvi saglabājiet maksimālo vērtību: Maksimālā kaudze nodrošina pastāvīgu piekļuvi maksimālajam kaudzes elementam, kas padara to noderīgu lietojumprogrammās, kur maksimālais elements ir jāatrod ātri.
- Efektīvas ievietošanas un dzēšanas darbības: Ievietošanas un dzēšanas operācijām maksimālajā kaudzē ir laika sarežģītība O(log n), kas padara tās efektīvas lielām elementu kolekcijām.
- Prioritārās rindas: Maksimālo kaudzi var izmantot, lai ieviestu prioritāro rindu, kas ir noderīga daudzās lietojumprogrammās, piemēram, darbu plānošanā, uzdevumu prioritāšu noteikšanā un uz notikumu balstītā simulācijā.
- Šķirošana: Maksimālo kaudzi var izmantot, lai ieviestu kaudzi, kas ir efektīvs kārtošanas algoritms, kura sliktākā gadījuma laika sarežģītība ir O(n log n).
- Kosmosa efektivitāte: Maksimālo kaudzi var ieviest kā masīvu, kas prasa mazāk atmiņas salīdzinājumā ar citām datu struktūrām, piemēram, bināro meklēšanas koku vai saistīto sarakstu.
Maksimālās kaudzes datu struktūra ir noderīgs un efektīvs rīks elementu kolekciju uzturēšanai un manipulēšanai, jo īpaši, ja ir ātri jāpiekļūst maksimālajam elementam vai ja elementi ir jākārto vai jānosaka prioritātes.
