A Min-Heap es defineix com un tipus de L'estructura de dades de pila és un tipus d'arbre binari que s'utilitza habitualment en informàtica per a diversos propòsits, com ara ordenar, cercar i organitzar dades.
Introducció a Min-Heap - Tutorials d'estructura de dades i algorisme
Propòsit i casos d'ús de Min-Heap:
- Implementació de la cua de prioritats: Un dels usos principals de l'estructura de dades d'heap és per implementar cues de prioritat.
- Algoritme de Dijkstra : L'algorisme de Dijkstra és un algorisme del camí més curt que troba el camí més curt entre dos nodes en un gràfic. Es pot utilitzar un munt mínim per fer un seguiment dels nodes no visitats amb la distància més petita del node font.
- Classificació: Es pot utilitzar un munt mínim com a algorisme d'ordenació per ordenar de manera eficient una col·lecció d'elements en ordre ascendent.
- Mitjana de la troballa: Es pot utilitzar un munt mínim per trobar de manera eficient la mediana d'un flux de números. Podem utilitzar un munt minut per emmagatzemar la meitat més gran dels números i un munt màxim per emmagatzemar la meitat més petita. La mediana serà l'arrel del munt mínim.
Estructura de dades Min-Heap en diferents idiomes:
1. Min-Heap en C++
Es pot implementar un munt mínim mitjançant l' priority_queue contenidor de la Biblioteca de plantilles estàndard (STL). El priority_queue El contenidor és un tipus d'adaptador de contenidor que proporciona una manera d'emmagatzemar elements en una estructura de dades semblant a una cua en la qual cada element té una prioritat associada.
Sintaxi :
C++
priority_queue < int, vector , més gran > minH;>>> 2. Min-Heap a Java
A Java, es pot implementar un munt mínim mitjançant el PriorityQueue classe des de paquet java.util . La classe PriorityQueue és una cua de prioritats que proporciona una manera d'emmagatzemar elements en una estructura de dades semblant a una cua en la qual cada element té una prioritat associada.
Sintaxi :
cua de prioritats
JavaMin-Heap en Python A Python, es pot implementar un munt mínim mitjançant el heapq mòdul, que proporciona funcions per implementar munts. Concretament, el heapq El mòdul proporciona una manera de crear i manipular estructures de dades de pila.
Sintaxi:
Python heap = [] heapify(heap)>
4. Min-Heap en C#
En C#, es pot implementar un munt mínim mitjançant la classe PriorityQueue de la System.Collections.Generic namespace . La classe PriorityQueue és una cua de prioritats que proporciona una manera d'emmagatzemar elements en una estructura de dades semblant a una cua en la qual cada element té una prioritat associada.
Sintaxi:
C# var minHeap = new PriorityQueue ();>
5. Min-heap en JavaScript
Un munt mínim és un arbre binari on cada node té un valor menor o igual que els seus fills. A JavaScript, podeu implementar un munt mínim mitjançant una matriu, on el primer element representa el node arrel i els fills d'un node a l'índex. i es troben en els índexs 2i+1 i 2i+2.
Sintaxi:
JavaScript const minHeap = new MinHeap();>
Diferència entre Min Heap i Max Heap:
Min Heap
Munt màxim
1.
En un Min-Heap, la clau present al node arrel ha de ser menor o igual que entre les claus presents a tots els seus fills.
En un Max-Heap, la clau present al node arrel ha de ser més gran o igual que entre les claus presents a tots els seus fills.
2.
En un Min-Heap l'element clau mínim està present a l'arrel.
En un Max-Heap l'element clau màxim està present a l'arrel.
Què és l'estructura en l'estructura de dades
3.
Un Min-Heap utilitza la prioritat ascendent.
Un Max-Heap utilitza la prioritat descendent.
4.
En la construcció d'un Min-Heap, l'element més petit té prioritat.
En la construcció d'un Max-Heap, l'element més gran té prioritat.
5.
En un munt min, l'element més petit és el primer que surt del munt.
En un Max-Heap, l'element més gran és el primer que surt del munt.
Implementació interna de l'estructura de dades min-heap:
A El munt mínim es representa normalment com una matriu .
- L'element arrel estarà a Arriba[0] .
- Per a qualsevol node i Arr[i] :
- Arr[(i -1) / 2] retorna el seu node pare.
- Arr[(2 * i) + 1] retorna el seu node fill esquerre.
- Arr[(2 * i) + 2] retorna el seu node fill dret.
La implementació interna del Min-Heap requereix 3 passos principals:
- Inserció : Per inserir un element al munt mínim, primer afegim l'element al final de la matriu i després ajustem la propietat del munt canviant repetidament l'element amb el seu pare fins que estigui a la posició correcta.
- Supressió : Per eliminar l'element mínim del munt mínim, primer intercanviem el node arrel amb l'últim element de la matriu, eliminem l'últim element i, a continuació, ajustem la propietat del munt intercanviant repetidament l'element amb el seu fill més petit fins que estigui al posició correcta.
- Heapify : Es pot utilitzar una operació heapify per crear un munt mínim a partir d'una matriu no ordenada.
Operacions sobre l'estructura de dades de min-heap i la seva implementació:
A continuació es mostren algunes operacions habituals que es poden realitzar en una estructura de dades heap,
1. Inserció a l'estructura de dades Min-Heap :
Els elements es poden inserir a la pila seguint un enfocament similar al que s'ha comentat anteriorment per a la supressió. La idea és:
- L'operació d'inserció en un min-heap implica els passos següents:
- Afegiu el nou element al final de la pila, a la següent posició disponible a l'últim nivell de l'arbre.
- Compareu l'element nou amb el seu pare. Si el pare és més gran que l'element nou, intercanvieu-los.
- Repetiu el pas 2 fins que el pare sigui més petit o igual que el nou element, o fins que el nou element arribi a l'arrel de l'arbre.
- El nou element es troba ara a la seva posició correcta a l'emmagatzematge mínim i la propietat de l'emmagatzematge s'ha satisfet.
Il·lustració:
Suposem que el munt és un munt mínim com:
és una relació
Inserció en Min-Heap
Implementació de l'operació d'inserció a Min-Heap:
C++ #include #include using namespace std; // Function to insert a new element into the min-heap void insert_min_heap(vector & heap, int valor) { // Afegeix el nou element al final de l'heap.push_back(valor); // Obteniu l'índex de l'últim element int index = heap.size() - 1; // Compara l'element nou amb el seu pare i intercanvia si // és necessari mentre (índex> 0 && heap[(índex - 1) / 2]> heap[índex]) { swap(heap[índex], heap[(índex - 1) / 2]); // Mou l'arbre amunt fins al pare de l'element // índex actual = (índex - 1) / 2; } } // Funció principal per provar la funció insert_min_heap int main() { vector Munt; valors int[] = { 10, 7, 11, 5, 4, 13 }; int n = sizeof(valors) / sizeof(valors[0]); per (int i = 0; i< n; i++) { insert_min_heap(heap, values[i]); cout << 'Inserted ' << values[i] << ' into the min-heap: '; for (int j = 0; j < heap.size(); j++) { cout << heap[j] << ' '; } cout << endl; } return 0; }>
Java import java.util.*; public class GFG { // Function to insert a new element into the min-heap public static void insertMinHeap(int[] heap, int size, int value) { // Add the new element to the end of the heap heap[size] = value; // Get the index of the last element int index = size; // Compare the new element with its parent and swap // if necessary while (index>0 && munt[(índex - 1) / 2]> munt[índex]) { swap (munt, índex, (índex - 1) / 2); // Mou l'arbre amunt fins al pare de l'element // índex actual = (índex - 1) / 2; } } // Funció per intercanviar dos elements en una matriu public static void swap(int[] arr, int i, int j) { int temp = arr[i]; arr[i] = arr[j]; arr[j] = temp; } // Funció principal per provar la funció insertMinHeap public static void main(String[] args) { int[] heap = new int[6]; int[] valors = { 10, 7, 11, 5, 4, 13 }; mida int = 0; per (int i = 0; i< values.length; i++) { insertMinHeap(heap, size, values[i]); size++; System.out.print('Inserted ' + values[i] + ' into the min-heap: '); for (int j = 0; j < size; j++) { System.out.print(heap[j] + ' '); } System.out.println(); } } }> Python 3 def insert_min_heap(heap, value): # Add the new element to the end of the heap heap.append(value) # Get the index of the last element index = len(heap) - 1 # Compare the new element with its parent and swap if necessary while index>0 i munt[(índex - 1) // 2]> munt[índex]: munt[índex], munt[(índex - 1) // 2] = munt[(índex - 1) // 2], munt[ índex] # Mou l'arbre cap al pare de l'element actual índex = (índex - 1) // 2 munt = [] valors = [10, 7, 11, 5, 4, 13] per al valor dels valors: insert_min_heap( munt, valor) print(f'S'ha inserit {valor} al munt mínim: {munt}')> C# using System; using System.Collections.Generic; public class Program { // Function to insert a new element into the min-heap static void InsertMinHeap(List heap, int value) { // Afegeix el nou element al final de l'heap.Add(valor); // Obteniu l'índex de l'últim element int index = heap.Count - 1; // Compara l'element nou amb el seu pare i intercanvia // si és necessari mentre (índex> 0 && heap[(índex - 1) / 2]> heap[índex]) { int temp = heap[índex]; munt[índex] = munt[(índex - 1) / 2]; munt[(índex - 1) / 2] = temp; // Mou l'arbre amunt fins al pare de l'element // índex actual = (índex - 1) / 2; } } // Funció principal per provar la funció InsertMinHeap public static void Main() { Llista heap = nova llista (); int[] valors = { 10, 7, 11, 5, 4, 13 }; foreach(int valor en valors) { InsertMinHeap (muntatge, valor); Console.Write('S'ha inserit ' + valor + ' al munt mínim: '); foreach(int element a l'heap) { Console.Write(element + ' '); } Console.WriteLine(); } } }>>> Javascript>>
Sortida Inserted 10 into the min-heap: 10 Inserted 7 into the min-heap: 7 10 Inserted 11 into the min-heap: 7 10 11 Inserted 5 into the min-heap: 5 7 11 10 Inserted 4 into the min-heap: 4 5 11 10 7 Inser...>
Complexitat temporal: O(log(n)) ( on n és el nombre d'elements del munt )
Espai auxiliar: O(n)
2. Supressió a l'estructura de dades de min-heap :
Eliminació de l'element més petit (l'arrel) del munt mínim. L'arrel es substitueix per l'últim element de l'emmagatzematge dinàmic i, a continuació, la propietat de l'muntatge es restaura canviant la nova arrel amb el seu fill més petit fins que el pare sigui més petit que els dos fills o fins que la nova arrel arribi a un node fulla.
- Substituïu l'arrel o l'element que s'ha de suprimir per l'últim element.
- Suprimeix l'últim element del munt.
- Com que l'últim element es col·loca ara a la posició del node arrel. Per tant, és possible que no segueixi la propietat heap. Per tant, amuntegueu l'últim node situat a la posició de l'arrel.
Il·lustració :
Suposem que el munt és un munt mínim com:
Estructura de dades min-heap
punters al cL'element que s'ha de suprimir és root, és a dir, 13.
Procés :
L'últim element és 100.
Pas 1: Substituïu l'últim element per root i suprimiu-lo.
Estructura de dades min-heap
Pas 2 : Heapify arrel.
Munt final:
Estructura de dades min-heap
Implementació de l'operació de supressió a Min-Heap:
C++ #include #include using namespace std; // Function to insert a new element into the min-heap void insert_min_heap(vector & heap, int valor) { // Afegeix el nou element al final de l'heap.push_back(valor); // Obteniu l'índex de l'últim element int index = heap.size() - 1; // Compara l'element nou amb el seu pare i intercanvia si // és necessari mentre (índex> 0 && heap[(índex - 1) / 2]> heap[índex]) { swap(heap[índex], heap[(índex - 1) / 2]); // Mou l'arbre amunt fins al pare de l'element // índex actual = (índex - 1) / 2; } } // Funció per eliminar un node del min-heap void delete_min_heap(vector & heap, int value) { // Troba l'índex de l'element que s'ha d'esborrar int index = -1; per (int i = 0; i< heap.size(); i++) { if (heap[i] == value) { index = i; break; } } // If the element is not found, return if (index == -1) { return; } // Replace the element to be deleted with the last // element heap[index] = heap[heap.size() - 1]; // Remove the last element heap.pop_back(); // Heapify the tree starting from the element at the // deleted index while (true) { int left_child = 2 * index + 1; int right_child = 2 * index + 2; int smallest = index; if (left_child < heap.size() && heap[left_child] < heap[smallest]) { smallest = left_child; } if (right_child < heap.size() && heap[right_child] < heap[smallest]) { smallest = right_child; } if (smallest != index) { swap(heap[index], heap[smallest]); index = smallest; } else { break; } } } // Main function to test the insert_min_heap and // delete_min_heap functions int main() { vector Munt; valors int[] = { 13, 16, 31, 41, 51, 100}; int n = sizeof(valors) / sizeof(valors[0]); per (int i = 0; i< n; i++) { insert_min_heap(heap, values[i]); } cout << 'Initial heap: '; for (int j = 0; j < heap.size(); j++) { cout << heap[j] << ' '; } cout << endl; delete_min_heap(heap, 13); cout << 'Heap after deleting 13: '; for (int j = 0; j < heap.size(); j++) { cout << heap[j] << ' '; } cout << endl; return 0; }>
Java import java.util.*; public class GFG { // Function to insert a new element into the min-heap public static void insertMinHeap(List heap, int value) { // Afegeix l'element nou al final de l'heap.add(valor); // Obteniu l'índex de l'últim element int index = heap.size() - 1; // Compara l'element nou amb el seu pare i intercanvia // si és necessari mentre (índex> 0 && heap.get((index - 1) / 2)> heap.get(index)) { Collections.swap(heap, index, (índex - 1) / 2); // Mou l'arbre amunt fins al pare de l'element // índex actual = (índex - 1) / 2; } } // Funció per eliminar un node del min-heap public static void deleteMinHeap(List heap, int value) { // Troba l'índex de l'element que s'ha d'esborrar int index = -1; per (int i = 0; i< heap.size(); i++) { if (heap.get(i) == value) { index = i; break; } } // If the element is not found, return if (index == -1) { return; } // Replace the element to be deleted with the last // element heap.set(index, heap.get(heap.size() - 1)); // Remove the last element heap.remove(heap.size() - 1); // Heapify the tree starting from the element at the // deleted index while (true) { int leftChild = 2 * index + 1; int rightChild = 2 * index + 2; int smallest = index; if (leftChild < heap.size() && heap.get(leftChild) < heap.get(smallest)) { smallest = leftChild; } if (rightChild < heap.size() && heap.get(rightChild) < heap.get(smallest)) { smallest = rightChild; } if (smallest != index) { Collections.swap(heap, index, smallest); index = smallest; } else { break; } } } // Main function to test the insertMinHeap and // deleteMinHeap functions public static void main(String[] args) { List heap = nova ArrayList (); int[] valors = { 13, 16, 31, 41, 51, 100}; int n = valors.longitud; per (int i = 0; i< n; i++) { insertMinHeap(heap, values[i]); } System.out.print('Initial heap: '); for (int j = 0; j < heap.size(); j++) { System.out.print(heap.get(j) + ' '); } System.out.println(); deleteMinHeap(heap, 13); System.out.print('Heap after deleting 13: '); for (int j = 0; j < heap.size(); j++) { System.out.print(heap.get(j) + ' '); } System.out.println(); } }> Python 3 def insert_min_heap(heap, value): heap.append(value) index = len(heap) - 1 while index>0 i munt[(índex - 1) // 2]> munt[índex]: munt[índex], munt[(índex - 1) // 2] = munt[(índex - 1) // 2], munt[ índex] índex = (índex - 1) // 2 def delete_min_heap (muntatge, valor): índex = -1 per a i en rang (len (munt)): si munt[i] == valor: índex = trencar si índex == -1: retorna heap[index] = heap[-1] heap.pop() mentre que True: left_child = 2 * índex + 1 right_child = 2 * índex + 2 més petit = índex si left_child< len(heap) and heap[left_child] < heap[smallest]: smallest = left_child if right_child < len(heap) and heap[right_child] < heap[smallest]: smallest = right_child if smallest != index: heap[index], heap[smallest] = heap[smallest], heap[index] index = smallest else: break heap = [] values = [13, 16, 31, 41, 51, 100] for value in values: insert_min_heap(heap, value) print('Initial heap:', heap) delete_min_heap(heap, 13) print('Heap after deleting 13:', heap)> C# using System; using System.Collections.Generic; class MinHeap { private List heap = llista nova (); public void Inserir (valor int) { heap.Add (valor); int índex = heap.Count - 1; while (índex> 0 && munt[(índex - 1) / 2]> munt[índex]) { Canvi (índex, (índex - 1) / 2); índex = (índex - 1) / 2; } } public void Delete(int value) { int index = heap.IndexOf(valor); if (índex == -1) { retorn; } munt[índex] = munt[munt.Compte - 1]; heap.RemoveAt(heap.Count - 1); while (true) { int leftChild = 2 * índex + 1; int rightChild = 2 * índex + 2; int més petit = índex; si (leftChild< heap.Count && heap[leftChild] < heap[smallest]) { smallest = leftChild; } if (rightChild < heap.Count && heap[rightChild] < heap[smallest]) { smallest = rightChild; } if (smallest != index) { Swap(index, smallest); index = smallest; } else { break; } } } private void Swap(int i, int j) { int temp = heap[i]; heap[i] = heap[j]; heap[j] = temp; } public void Print() { for (int i = 0; i < heap.Count; i++) { Console.Write(heap[i] + ' '); } Console.WriteLine(); } } class Program { static void Main(string[] args) { MinHeap heap = new MinHeap(); int[] values = { 13, 16, 31, 41, 51, 100 }; for (int i = 0; i < values.Length; i++) { heap.Insert(values[i]); } Console.Write('Initial heap: '); heap.Print(); heap.Delete(13); Console.Write('Heap after deleting 13: '); heap.Print(); } }> Javascript function insertMinHeap(heap, value) { // Add the new element to the end of the heap heap.push(value); // Get the index of the last element let index = heap.length - 1; // Compare the new element with its parent and swap if necessary for (let flr = Math.floor((index - 1) / 2); index>0 && heap[flr]> heap[índex]; flr = Math.floor((índex - 1) / 2)) { [munt[índex], munt[flr]] = [ munt[flr], munt[índex], ]; // Mou l'arbre amunt fins al pare de l'element actual índex = Math.floor((índex - 1) / 2); } } function deleteMinHeap(heap, value) { // Troba l'índex de l'element a eliminar let index = -1; per (sigui i = 0; i< heap.length; i++) { if (heap[i] == value) { index = i; break; } } // If the element is not found, return if (index == -1) { return; } // Replace the element to be deleted with the last element heap[index] = heap[heap.length - 1]; // Remove the last element heap.pop(); // Heapify the tree starting from the element at the deleted index while (true) { let left_child = 2 * index + 1; let right_child = 2 * index + 2; let smallest = index; if (left_child < heap.length && heap[left_child] < heap[smallest]) { smallest = left_child; } if (right_child < heap.length && heap[right_child] < heap[smallest]) { smallest = right_child; } if (smallest != index) { [heap[index], heap[smallest]] = [heap[smallest], heap[index]]; index = smallest; } else { break; } } } // Main function to test the insertMinHeap and deleteMinHeap functions let heap = []; let values = [13, 16, 31, 41, 51, 100]; for (let i = 0; i < values.length; i++) { insertMinHeap(heap, values[i]); } console.log('Initial heap: ' + heap.join(' ')); deleteMinHeap(heap, 13); console.log('Heap after deleting 13: ' + heap.join(' '));> Sortida
Espai auxiliar: O(n)
3. Operació d'ull a l'estructura de dades Min-Heap:
Per accedir a l'element mínim (és a dir, l'arrel de la pila), es retorna el valor del node arrel. La complexitat temporal del peek en un munt min és O(1).
Estructura de dades min Heap
Implementació de l'operació Peek a Min-Heap:
C++ #include #include #include using namespace std; int main() { // Create a max heap with some elements using a // priority_queue priority_queue , més gran > minHeap; minHeap.push(9); minHeap.push(8); minHeap.push(7); minHeap.push(6); minHeap.push(5); minHeap.push(4); minHeap.push(3); minHeap.push(2); minHeap.push(1); // Obteniu l'element pic (és a dir, l'element més gran) int peakElement = minHeap.top(); // Imprimeix el pic de l'element 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 minHeap = new PriorityQueue(); minHeap.add(9); minHeap.add(8); minHeap.add(7); minHeap.add(6); minHeap.add(5); minHeap.add(4); minHeap.add(3); minHeap.add(2); minHeap.add(1); // Obté l'element pic (és a dir, l'element més gran) int peakElement = minHeap.peek(); // Imprimeix l'element pic System.out.println('Element pic: ' + peakElement); } }>>> using System; using System.Collections.Generic; public class GFG { public static void Main() { // Create a min heap with some elements using a // PriorityQueue var minHeap = new PriorityQueue (); minHeap.Enqueue(9); minHeap.Enqueue(8); minHeap.Enqueue(7); minHeap.Enqueue(6); minHeap.Enqueue(5); minHeap.Enqueue(4); minHeap.Enqueue(3); minHeap.Enqueue(2); minHeap.Enqueue(1); // Obté l'element pic (és a dir, l'element més petit) int peakElement = minHeap.Peek(); // Imprimeix l'element pic Console.WriteLine('Element pic: ' + peakElement); } }>>> Sortida
En un munt mínim implementat mitjançant un arbre binari, també es pot accedir a l'element pic en temps O(1), ja que sempre es troba a l'arrel de l'arbre.
Espai auxiliar: O(n)
4. Operació Heapify a l'estructura de dades Min-Heap:
Es pot utilitzar una operació d'heapify per crear un munt mínim a partir d'una matriu no ordenada. Això es fa començant a l'últim node que no és full i realitzant repetidament l'operació de bombolla avall fins que tots els nodes compleixin la propietat de l'munt.
Operació Heapify a Min Heap
Implementació de l'operació Heapify en Min-Heap:
C++ #include #include using namespace std; void minHeapify(vector &arr, int i, int n) { int més petit = i; int l = 2*i + 1; int r = 2*i + 2; si (l< n && arr[l] < arr[smallest]) smallest = l; if (r < n && arr[r] < arr[smallest]) smallest = r; if (smallest != i) { swap(arr[i], arr[smallest]); minHeapify(arr, smallest, n); } } int main() { vector arr = {10, 5, 15, 2, 20, 30}; cout<< 'Original array: '; for (int i = 0; i < arr.size(); i++) cout << arr[i] << ' '; // Perform heapify operation on min-heap for (int i = arr.size()/2 - 1; i>= 0; i--) minHeapify(arr, i, arr.size()); cout<< '
Min-Heap after heapify operation: '; for (int i = 0; i < arr.size(); i++) cout << arr[i] << ' '; return 0; }>
Java // Java code of Heapify operation in Min-Heap import java.util.Arrays; import java.util.List; public class Main { // Function to maintain the min-heap property of the heap rooted at index 'i' public static void minHeapify(List arr, int i, int n) { // Suposem que l'arrel és l'element més petit inicialment int smallest = i; // Calcula els índexs del fill esquerre i dret del node actual int l = 2 * i + 1; int r = 2 * i + 2; // Compara el fill esquerre amb el més petit actual si (l< n && arr.get(l) < arr.get(smallest)) smallest = l; // Compare the right child with the current smallest if (r < n && arr.get(r) < arr.get(smallest)) smallest = r; // If the current node is not the smallest, swap it with the smallest child if (smallest != i) { int temp = arr.get(i); arr.set(i, arr.get(smallest)); arr.set(smallest, temp); // Recursively heapify the subtree rooted at the smallest child minHeapify(arr, smallest, n); } } public static void main(String[] args) { // Create a list representing the array List arr = Arrays.asList(10, 5, 15, 2, 20, 30); System.out.print('Matriu original: '); // Imprimeix la matriu original per a (int i = 0; i< arr.size(); i++) System.out.print(arr.get(i) + ' '); // Perform heapify operation on the min-heap // Start from the last non-leaf node and go up to the root of the tree for (int i = arr.size() / 2 - 1; i>= 0; i--) minHeapify(arr, i, arr.size()); System.out.print('
Min-Heap després de l'operació heapify: '); // Imprimeix el min-heap després de l'operació heapify per a (int i = 0; i< arr.size(); i++) System.out.print(arr.get(i) + ' '); } }> Python def minHeapify(arr, i, n): smallest = i left = 2 * i + 1 right = 2 * i + 2 if left < n and arr[left] < arr[smallest]: smallest = left if right < n and arr[right] < arr[smallest]: smallest = right if smallest != i: arr[i], arr[smallest] = arr[smallest], arr[i] minHeapify(arr, smallest, n) if __name__ == '__main__': arr = [10, 5, 15, 2, 20, 30] print('Original array:', arr) # Perform heapify operation on a min-heap for i in range(len(arr) // 2 - 1, -1, -1): minHeapify(arr, i, len(arr)) print('Min-Heap after heapify operation:', arr)> C# using System; using System.Collections.Generic; class GFG { // Function to perform the minHeapify operation on a min-heap. static void MinHeapify(List arr, int i, int n) { int més petit = i; int esquerre = 2 * i + 1; int dret = 2 * i + 2; // Compara el fill esquerre amb el node més petit actual. si (esquerra< n && arr[left] < arr[smallest]) smallest = left; // Compare the right child with the current smallest node. if (right < n && arr[right] < arr[smallest]) smallest = right; // If the current node is not the smallest // swap it with the smallest child. if (smallest != i) { int temp = arr[i]; arr[i] = arr[smallest]; arr[smallest] = temp; // Recursively call minHeapify on the affected subtree. MinHeapify(arr, smallest, n); } } static void Main(string[] args) { List arr = nova llista {10, 5, 15, 2, 20, 30}; Console.Write('Matriu original: '); foreach (número int a arr) Consola.Escriu (número + ' '); // Realitzeu l'operació heapify al min-heap. for (int i = arr.Count / 2 - 1; i>= 0; i--) MinHeapify(arr, i, arr.Count); Console.Write('
Min-Heap després de l'operació heapify: '); foreach (número int a arr) Consola.Escriu (número + ' '); } }>>> Sortida
5. Operació de cerca a Min-Heap Data Structure:
Per cercar un element al munt mínim, es pot realitzar una cerca lineal sobre la matriu que representa el munt. Tanmateix, la complexitat temporal d'una cerca lineal és O(n), que no és eficient. Per tant, la cerca no és una operació d'ús habitual en un munt de min.
Aquí hi ha un codi d'exemple que mostra com cercar un element en un munt min std::find() :
C++ #include using namespace std; int main() { priority_queue , més gran > min_heap; // exemple max heap min_heap.push(10); min_heap.push(9); min_heap.push(8); min_heap.push(6); min_heap.push(4); int element = 6; // element per cercar bool trobat = fals; // Copieu l'heap min a una cua temporal i cerqueu // l'element std::priority_queue , més gran > temp = min_heap; mentre que (!temp.empty()) { if (temp.top () == element) { trobat = cert; trencar; } temp.pop(); } si (trobat) { std::cout<< 'Element found in the min heap.' << std::endl; } else { std::cout << 'Element not found in the min heap.' << std::endl; } return 0; }> Java import java.util.PriorityQueue; public class GFG { public static void main(String[] args) { PriorityQueue min_heap = new PriorityQueue(); min_heap.add(3); // inserir elements a la cua de prioritat min_heap.offer(1); min_heap.offer(4); min_heap.offer(1); min_heap.offer(6); int element = 6; // element per cercar booleà trobat = fals; // Copieu l'heap min a una cua temporal i cerqueu // l'element PriorityQueue temp = new PriorityQueue(min_heap); mentre que (!temp.isEmpty()) { if (temp.poll() == element) { trobat = cert; trencar; } } if (trobat) { System.out.println('Element trobat a la pila mínima.'); } else { System.out.println('L'element no s'ha trobat al munt mínim.'); } } }>>> using System; using System.Collections.Generic; public class GFG { public static void Main() { var minHeap = new PriorityQueue (); // exemple min Heap minHeap.Enqueue(4); minHeap.Enqueue(6); minHeap.Enqueue(8); minHeap.Enqueue(9); minHeap.Enqueue(10); int element = 6; // element per cercar bool trobat = fals; // Copieu el munt mínim a una cua temporal i cerqueu // l'element var temp = new PriorityQueue (minHeap); while (temp.Compte> 0) { if (temp.Peek() == element) { trobat = cert; trencar; } temp.Dequeue(); } if (trobat) { Console.WriteLine( 'Element trobat a l'heap min.'); } else { Console.WriteLine('L'element no s'ha trobat al munt mínim.'); } } }>> Javascript // Example min heap let minHeap = new PriorityQueue(); minHeap.enqueue(4); minHeap.enqueue(6); minHeap.enqueue(8); minHeap.enqueue(9); minHeap.enqueue(10); let element = 6; // Element to search for let found = false; // Copy the min heap to a temporary queue and search for the element let temp = new PriorityQueue(minHeap); while (temp.size()>0) { if (temp.peek() == element) { trobat = cert; trencar; } temp.dequeue(); } if (trobat) { console.log('Element trobat a la pila mínima.'); } else { console.log('L'element no s'ha trobat a la pila mínima.'); }>>>Sortida
L'operació d'inserció té una complexitat temporal de O(log n) en el pitjor dels casos perquè s'ha de mantenir la propietat heap. L'operació de cerca consisteix a copiar la cua de prioritat a una cua temporal i després travessar la cua temporal, que pren O(n log n) temps en el pitjor dels casos perquè cada element s'ha de copiar i treure de la cua, i la cua de prioritat s'ha de reconstruir per a cada operació.
java 8
El complexitat espacial del programa és O(n) perquè emmagatzema n elements a la cua de prioritats i crea una cua temporal amb n elements.
Aplicacions de l'estructura de dades min-heap:
- Classificació de pila: El munt mínim s'utilitza com a component clau en l'algorisme d'ordenació del munt, que és un algorisme d'ordenació eficient amb una complexitat temporal de O(nlogn).
- Cua de prioritats: Es pot implementar una cua de prioritat utilitzant una estructura de dades d'heap min on l'element amb el valor mínim és sempre a l'arrel.
- Algorisme de Dijkstra: En l'algorisme de Dijkstra, s'utilitza un munt mínim per emmagatzemar els vèrtexs del gràfic amb la distància mínima des del vèrtex inicial. El vèrtex amb la distància mínima és sempre a l'arrel del munt.
- Codificació Huffman: A la codificació Huffman, s'utilitza un munt min per implementar una cua de prioritats per crear un codi de prefix òptim per a un conjunt determinat de caràcters.
- Combina K matrius ordenades: Tenint en compte les matrius ordenades K, podem combinar-les en una única matriu ordenada de manera eficient mitjançant una estructura de dades min.
Avantatges de l'estructura de dades de min-heap:
- Inserció i eliminació eficients : El munt mínim permet la inserció i la supressió ràpides d'elements amb una complexitat temporal de O(log n), on n és el nombre d'elements del munt.
- Recuperació eficient de l'element mínim: L'element mínim d'un munt mínim sempre es troba a l'arrel del munt, que es pot recuperar en temps O(1).
- Espai eficient: Min Heap és una estructura de dades compacta que es pot implementar mitjançant una matriu o un arbre binari, cosa que fa que sigui eficient en l'espai.
- Classificació: El munt mínim es pot utilitzar per implementar un algorisme d'ordenació eficient com ara l'ordenació del munt amb una complexitat temporal de O(n log n).
- Cua de prioritats: L'heap mínim es pot utilitzar per implementar una cua de prioritats, on l'element amb la prioritat mínima es pot recuperar de manera eficient en temps O(1).
- Versatilitat: Min Heap té diverses aplicacions en informàtica, com ara algorismes de gràfics, compressió de dades i sistemes de bases de dades.
En general, min heap és una estructura de dades útil i versàtil que ofereix operacions eficients, eficiència espacial i té diverses aplicacions en informàtica.