Le programmeur peut facilement récupérer l'élément maximum en utilisant le ' Tas maximum ” arbre binaire. Comme dans cet arbre, l'élément maximum réside toujours au nœud supérieur de l'arbre qui est connu sous le nom de ' racine ” nœud. De plus, il offre une insertion et une suppression efficaces des éléments tout en maintenant l'ordre trié. De plus, un 'Max Heap' peut facilement effectuer des tâches planifiées en fonction de leur priorité ou d'autres critères.
Cet article explique le contenu suivant :
- Comment utiliser Max Heap en Java ?
- Utilisez la méthode 'maxHeapify()'
- Utilisez la méthode 'Collections.reverseOrder()'
Comment utiliser Max Heap en Java ?
UN ' Tas maximum ” est utilisé comme structure de données sous-jacente pour implémenter une file d'attente prioritaire. Dans la file d'attente prioritaire, les données sont traitées en fonction de leur valeur de priorité attribuée. Il peut également être utilisé pour trier efficacement les éléments de données par ordre décroissant.
Le 'Max Heap' peut être généré à l'aide de deux méthodes décrites dans l'exemple de codec ci-dessous :
Méthode 1 : Utilisez la méthode 'maxHeapify()'
Le ' maxHeapify() ” méthode génère un “ Tas maximum » à partir d'une collection d'éléments existante en transformant les structures de données. De plus, cette méthode aide à modifier la matrice d'origine en place, réduisant ainsi le besoin de mémoire supplémentaire.
Par exemple, visitez le code ci-dessous pour générer un ' Tas maximum » en utilisant la méthode « maxHeapify() » :
importer java.util.ArrayList ;importer java.util.Collections ;
importer java.util.List ;
classe publique MaxHeapifyExam {
public statique vide principal ( Chaîne [ ] arguments ) // création de la principale ( ) méthode
{
Liste < Entier > testsEle = nouvelle ArrayList <> ( ) ;
testEle.add ( 5 ) ;
testEle.add ( 3 ) ;
testEle.add ( 8 ) ;
testEle.add ( 2 ) ;
testEle.add ( 1 ) ;
testEle.add ( 7 ) ;
System.out.println ( 'Liste originale : ' + essais ) ;
maxHeapify ( TESTS ) ;
System.out.println ( « Le tas maximal généré : » + essais ) ;
}
vide statique privé maxHeapify ( Liste < Entier > TESTS ) {
int k = testEle.taille ( ) ;
pour ( entier je = k / 2 - 1 ; je > = 0 ; je-- ) {
entasser ( testsEle, k, i ) ;
}
}
vide statique privé heapify ( Liste < Entier > testsEle, int k, int i ) {
int plus grand = i ;
int LeftSide = 2 * je + 1 ;
int côtédroit = 2 * je + 2 ;
si ( côté gauche < k && testEle.get ( côté gauche ) > testEle.get ( plus grand ) ) {
plus grand = leftSide ;
}
si ( côté droit < k && testEle.get ( côté droit ) > testEle.get ( plus grand ) ) {
plus grand = rightSide ;
}
si ( plus grand ! = je ) {
Collections.swap ( testsEle, je, supérieur ) ;
entasser ( testsEle, k, supérieur ) ;
}
}
}
Explication du code ci-dessus :
- Tout d'abord, la liste ' TESTS ' est initialisé avec des éléments de données factices dans le ' principal() ” méthode et imprimé sur la console.
- Ensuite, la liste 'testEle' est transmise à la fonction 'maxHeapify ()', puis la liste renvoyée s'affiche sur la console.
- Puis le ' maxHeapify() ” est initialisée et la taille de la liste fournie est récupérée en utilisant le “ taille() ' méthode.
- Ensuite, utilisez le ' pour ” pour définir la structure du tas et calculer la position de chaque nœud.
- Maintenant, utilisez le ' entasser() ” et définissez la position des nœuds “top”, “left” et “right” en attribuant des valeurs aux variables “greater”, “leftSide” et “rightSide”, respectivement.
- Après cela, utilisez plusieurs ' si ” instructions conditionnelles pour vérifier si le “ côté gauche ” nœud est plus grand que le “ côté droit ” nœud et vice versa. En fin de compte, la plus grande valeur est stockée dans le ' plus grand ” nœud.
- Enfin, le nouveau ' plus grand ” la valeur du nœud est vérifiée avec la valeur déjà stockée dans le “ plus grand ” variable de nœud. Et le ' échanger() ” fonctionne en conséquence pour définir la plus grande valeur dans le “ plus grand ” variables.
Après la fin de la phase d'exécution :
L'instantané montre que le tas maximum est généré à l'aide de ' maxHeapify() ” méthode en Java.
Méthode 2 : Utilisez la méthode « Collections.reverseOrder() »
Le ' Collections.reverseOrder() ” offre une méthode simple et concise pour générer un “ Tas maximum ” en triant la collection dans l'ordre inverse. Cela permet au code d'être réutilisé et évite d'avoir à implémenter le ' entasser ” logique, comme indiqué dans l'extrait de code ci-dessous :
importer java.util.ArrayList ;importer java.util.Collections ;
importer java.util.List ;
classe publique ReverseOrderExample {
public statique vide principal ( Chaîne [ ] arguments ) // création de la principale ( ) méthode
{
Liste < Entier > testsEle = nouvelle ArrayList <> ( ) ;
testEle.add ( 5 ) ;
testEle.add ( 38 ) ;
testEle.add ( 98 ) ;
testEle.add ( 26 ) ;
testEle.add ( 1 ) ;
testEle.add ( 73 ) ;
System.out.println ( 'Liste originale : ' + essais ) ;
Collections.sort ( testsEle, Collections.reverseOrder ( ) ) ;
System.out.println ( « Le tas maximal généré : » + essais ) ;
}
}
Explication du code ci-dessus :
- Tout d'abord, importez le ' Liste des tableaux ”, “ Collections ' et ' Liste ” utilitaires dans le fichier Java.
- Ensuite, créez un ' Liste ' nommé ' TESTS ” et insérer des éléments factices dans la liste.
- Ensuite, le « trier() La méthode ' est utilisée pour trier les éléments de données dans l'ordre croissant et passer la liste en tant que paramètre le long de la ' Collections.reverseOrder() ' méthode. Cela rend le tri des ' TESTS » liste dans l'ordre inverse.
Après la fin de la phase d'exécution :
L'instantané montre que 'Max Heap' est généré et trié à l'aide de la méthode 'Collections.reverseOrder()'.
Conclusion
En créant un « Tas maximum », les utilisateurs peuvent utiliser les méthodes « maxHeapify() » et « Collections.reverseOrder() ». Ils gèrent une collection d'éléments de manière à permettre un accès rapide au maximum d'éléments et un maintien efficace d'un ordre trié. Cela dépend uniquement des exigences spécifiques et du niveau de contrôle nécessaire sur le processus de création de tas.