UN tas maximum est un arbre binaire complet dans lequel la valeur de chaque nœud interne est supérieure ou égale aux valeurs des enfants de ce nœud. Mapper les éléments d'un tas dans un tableau est trivial : si un nœud est stocké à l'index k, alors son enfant de gauche est stocké à l'index 2k + 1 et son enfant droit à l'index 2k + 2.
Illustration: Tas maximum
Comment Max Heap est-il représenté ?
A-Max Heap est un arbre binaire complet. Le tas A-Max est généralement représenté sous forme de tableau. L'élément racine sera à Arr[0]. Le tableau ci-dessous montre les index des autres nœuds pour le avec nœud, c'est-à-dire Arr[i] :
Arr[(i-1)/2] Renvoie le nœud parent.
Arr[(2*i)+1] Renvoie le nœud enfant gauche.
Arr[(2*i)+2] Renvoie le nœud enfant droit.
Les opérations sur Max Heap sont les suivantes :
- getMax() : Il renvoie l'élément racine de Max Heap. La complexité temporelle de cette opération est O(1) .
- extraireMax() : Supprime le maximum d'éléments de Tas maximum . La complexité temporelle de cette opération est O (Journal n) car cette opération doit maintenir la propriété du tas en appelant le méthode heapify() après avoir retiré la racine.
- insérer(): L'insertion d'une nouvelle clé prend O (Journal n) temps. Nous ajoutons une nouvelle clé à la fin de l'arborescence. Si la nouvelle clé est plus petite que son parent, nous n’avons rien à faire. Sinon, nous devons remonter pour corriger la propriété du tas violée.
Note: Dans l'implémentation ci-dessous, nous effectuons une indexation à partir de l'index 1 pour simplifier l'implémentation.
Méthodes :
Il existe 2 méthodes par lesquelles nous pouvons atteindre l’objectif indiqué :
- Approche basique en créant maxHeapify() méthode
- En utilisant Collections.reverseOrder() méthode via la bibliothèque Fonctions
Méthode 1 : Approche basique en créant maxHeapify() méthode
Nous allons créer une méthode en supposant que les sous-arbres gauche et droit sont déjà remplis, il nous suffit de corriger la racine.
actrice de cinéma Kajal
Exemple
Java
// Java program to implement Max Heap> // Main class> public> class> MaxHeap {> >private> int>[] Heap;> >private> int> size;> >private> int> maxsize;> >// Constructor to initialize an> >// empty max heap with given maximum> >// capacity> >public> MaxHeap(>int> maxsize)> >{> >// This keyword refers to current instance itself> >this>.maxsize = maxsize;> >this>.size =>0>;> >Heap =>new> int>[>this>.maxsize];> >}> >// Method 1> >// Returning position of parent> >private> int> parent(>int> pos) {>return> (pos ->1>) />2>; }> >// Method 2> >// Returning left children> >private> int> leftChild(>int> pos) {>return> (>2> * pos) +>1>; }> >// Method 3> >// Returning right children> >private> int> rightChild(>int> pos)> >{> >return> (>2> * pos) +>2>;> >}> >// Method 4> >// Returning true if given node is leaf> >private> boolean> isLeaf(>int> pos)> >{> >if> (pos>(taille />2>) && pos <= size) {> >return> true>;> >}> >return> false>;> >}> >// Method 5> >// Swapping nodes> >private> void> swap(>int> fpos,>int> spos)> >{> >int> tmp;> >tmp = Heap[fpos];> >Heap[fpos] = Heap[spos];> >Heap[spos] = tmp;> >}> >// Method 6> >// Recursive function to max heapify given subtree> >private> void> maxHeapify(>int> pos)> >{> >if> (isLeaf(pos))> >return>;> >if> (Heap[pos] || Heap[pos] if (Heap[leftChild(pos)]>Tas[rightChild(pos)]) { swap(pos, leftChild(pos)); maxHeapify(leftChild(pos)); } autre { swap(pos, rightChild(pos)); maxHeapify(rightChild(pos)); } } } // Méthode 7 // Insère un nouvel élément dans le tas maximum public void insert(int element) { Heap[size] = element; // Traverse vers le haut et corrige la propriété violée int current = size; while (Heap[current]> Heap[parent(current)]) { swap(current, parent(current)); actuel = parent (actuel); } taille++; } // Méthode 8 // Pour afficher le tas public void print() { for (int i = 0; i 2; i++) { System.out.print('Parent Node : ' + Heap[i]); if (leftChild(i) // si l'enfant est hors des limites // du tableau System.out.print(' Left Child Node: ' + Heap[leftChild(i)]); if (rightChild(i) ) // l'index enfant droit ne doit pas // être hors de l'index du tableau System.out.print(' Right Child Node: ' + Heap[rightChild(i)]); ; // pour une nouvelle ligne } } // Méthode 9 // Supprime un élément du tas maximum public int extractMax() { int popped = Heap[0] = Heap[--size]; ; return popped; } // Méthode 10 // méthode du pilote principal public static void main(String[] arg) { // Afficher le message pour une meilleure lisibilité System.out.println('Le tas maximum est '); = new MaxHeap(15); // Insertion de nœuds // Entrées personnalisées maxHeap.insert(5); maxHeap.insert(17); maxHeap.insert(19); maxHeap.insert(6); maxHeap.insert(22); maxHeap.insert(9); // Appel de maxHeap() comme défini ci-dessus maxHeap.print(); valeur dans le tas System.out.println('La valeur maximale est ' + maxHeap.extractMax()); } }> |
>
>Sortir
The Max Heap is Parent Node : 84 Left Child Node: 22 Right Child Node: 19 Parent Node : 22 Left Child Node: 17 Right Child Node: 10 Parent Node : 19 Left Child Node: 5 Right Child Node: 6 Parent Node : 17 Left Child Node: 3 Right Child Node: 9 The max val is 84>
Méthode 2 : Utilisation de la méthode Collections.reverseOrder() via les fonctions de la bibliothèque
Nous utilisons la classe PriorityQueue pour implémenter Heaps en Java. Par défaut, Min Heap est implémenté par cette classe. Pour implémenter Max Heap, nous utilisons la méthode Collections.reverseOrder().
Exemple
Java
quel est le numéro de l'alphabet
// Java program to demonstrate working> // of PriorityQueue as a Max Heap> // Using Collections.reverseOrder() method> // Importing all utility classes> import> java.util.*;> // Main class> class> GFG {> >// Main driver method> >public> static> void> main(String args[])> >{> >// Creating empty priority queue> >PriorityQueue pQueue> >=>new> PriorityQueue(> >Collections.reverseOrder());> >// Adding items to our priority queue> >// using add() method> >pQueue.add(>10>);> >pQueue.add(>30>);> >pQueue.add(>20>);> >pQueue.add(>400>);> >// Printing the most priority element> >System.out.println(>'Head value using peek function:'> >+ pQueue.peek());> >// Printing all elements> >System.out.println(>'The queue elements:'>);> >Iterator itr = pQueue.iterator();> >while> (itr.hasNext())> >System.out.println(itr.next());> >// Removing the top priority element (or head) and> >// printing the modified pQueue using poll()> >pQueue.poll();> >System.out.println(>'After removing an element '> >+>'with poll function:'>);> >Iterator itr2 = pQueue.iterator();> >while> (itr2.hasNext())> >System.out.println(itr2.next());> >// Removing 30 using remove() method> >pQueue.remove(>30>);> >System.out.println(>'after removing 30 with'> >+>' remove function:'>);> >Iterator itr3 = pQueue.iterator();> >while> (itr3.hasNext())> >System.out.println(itr3.next());> >// Check if an element is present using contains()> >boolean> b = pQueue.contains(>20>);> >System.out.println(>'Priority queue contains 20 '> >+>'or not?: '> + b);> >// Getting objects from the queue using toArray()> >// in an array and print the array> >Object[] arr = pQueue.toArray();> >System.out.println(>'Value in array: '>);> >for> (>int> i =>0>; i System.out.println('Value: ' + arr[i].toString()); } }> |
>
>Sortir
Head value using peek function:400 The queue elements: 400 30 20 10 After removing an element with poll function: 30 10 20 after removing 30 with remove function: 20 10 Priority queue contains 20 or not?: true Value in array: Value: 20 Value: 10>