File d'attente prioritaire en java

Supposons que vous offrez un service à trois personnes différentes debout devant vous. La troisième personne se trouve être votre ami. Le service est censé être servi du premier arrivé. Avec le premier-de -mon_first servait, la première personne a la plus grande priorité; La deuxième personne a la plus grande priorité; la troisième personne, la moindre priorité, etc. Vous ne serez pas puni, si vous n'observerez pas le premier-endroit_. Vous avez décidé de servir votre ami d'abord, puis la première personne, suivie de la deuxième personne. Cela signifie que vous avez donné à votre ami la plus grande priorité. En regardant le scénario du point de vue d'un robot, la troisième position avait la plus grande priorité.

Le lendemain, les trois mêmes personnes sont venues. Cette fois, votre ami est au milieu. Vous avez décidé de le servir en premier, devant la personne qui est venue en premier, puis la troisième personne, et enfin la première personne. Ainsi, cette fois, selon le robot, la position 2 a la plus grande priorité, suivie de la position 3.

Le troisième jour, votre ami est le premier, et vous faites le premier-endroit_. La conclusion de quiconque et du robot est que la priorité dépend de qui est concerné et de la position de chaque personne. Remarque: Dans la vraie vie, la priorité ne dépend pas toujours du premier de celui-ci_first servi.

En programmation, une file d'attente de priorité binaire est l'endroit où le premier élément a la plus grande priorité. Le troisième élément peut avoir la plus grande priorité et le deuxième élément, la troisième priorité. Les files d'attente prioritaires sont de nature binaire. Remarque: le premier élément est toujours la plus grande priorité dans une file d'attente de priorité. Il peut également arriver que le deuxième élément ait la plus grande priorité et que le troisième élément ait la troisième priorité. Dans la définition de la file d'attente de priorité, les priorités des deuxième et troisième éléments peuvent ne pas être en ordre décroissant. Cette différence continue dans la file d'attente jusqu'au dernier élément, ce qui peut ne pas être le moindre élément de priorité. Cependant, ce sera parmi ceux de la priorité la plus basse. Ce sort partiel est également connu sous le nom d'ordre partiel. Ainsi, une file d'attente prioritaire est une file d'attente d'ordre partiel, où la priorité n'est pas le premier de l'or.

Lorsque vous traitez avec le tableau, le premier-de -do. En informatique, la file d'attente est le FIFO, tandis que la file d'attente prioritaire est un FIFO partiel car comme la file d'attente descend, certains éléments ont des priorités supérieures à leurs prédécesseurs. Au fur et à mesure que la file d'attente des priorités descend, la distance entre ces prédécesseurs proches et les priorités plus élevées augmente.

Une file d'attente prioritaire est implémentée comme une structure de données de tas. La question suivante est: qu'est-ce qu'un tas? Il y a le tas maximum et le tas minimum, qui sera discuté en détail ci-dessous.

Contenu de l'article

• Structure de données de tas
• File d'attente prioritaire en java propre
• Construction Java d'une file d'attente prioritaire
• Méthodes Java d'une file d'attente prioritaire
• Conclusion

Structure de données de tas

Il y a un maximum de max, et il y a un mine-heap. Avec Max-Heap, le premier élément est la plus grande valeur. Au fur et à mesure que la file d'attente descend, les valeurs continuent de diminuer, d'augmenter et de diminuer généralement. Avec min-heap, le premier élément est la plus petite valeur. Alors que la file d'attente descend, les valeurs continuent d'augmenter et de diminuer et augmenter généralement. Les valeurs d'un tas peuvent être conservées dans un tableau.

Un tas binaire est l'endroit où un nœud (article) a deux enfants. Le premier enfant est l'enfant gauche et le deuxième enfant est le bon enfant. La valeur de tout nœud est appelée clé.

Maximum

La liste suivante est un maximum de max qui est déjà partiellement commandé et n'a pas besoin d'une autre commande:

89, 85, 87, 84, 82, 79, 73, 80, 81 ,, 65, 69

89 est la première valeur à l'index 0. C'est le nœud racine (parent racine). C'est la plus grande valeur parmi toutes les valeurs. Son premier enfant (85) est à l'indice 1, dont l'indice est égal à 2 (0) + 1, où 0 est l'index du parent. Son deuxième enfant (87) est à l'indice 2, qui est égal à 2 (0) + 2, où 0 est l'index du parent.

85 est à l'index 1. C'est un parent. Son premier enfant (84) est à l'indice 3, qui est égal à 2 (1) + 1, où 1 est l'indice du parent. Son deuxième enfant (82) est à l'indice 4, qui est égal à 2 (1) + 2, où 1 est l'indice du parent.

87 est à l'index 2. C'est un parent. Son premier enfant (79) est à l'indice 5, qui est égal à 2 (2) + 1, où 2 est l'indice du parent. Son deuxième enfant (73) est à l'indice 6, qui est égal à 2 (2) + 2, où 2 est l'indice du parent.

En général, au fur et à mesure que le comptage d'index commence à partir de 0, je représente l'indice d'un parent du tableau; Et donc, le (premier) enfant gauche d'un parent à l'index I est à l'index 2i + 1; et son (deuxième) enfant droit, est à l'index 2i + 2. Certaines cellules vers la fin du tableau peuvent être vides; Ils ne doivent pas avoir de valeurs.

La liste précédente est un bon exemple du contenu d'une file d'attente prioritaire une fois que l'inclusion des éléments est terminée. Si le premier élément est supprimé, les autres sont réorganisés pour que les valeurs soient la configuration, formant une nouvelle file d'attente de priorité. De cette façon, la suppression de tous les éléments du haut apparaîtrait comme si tous les éléments étaient triés correctement. Les éléments peuvent encore être obtenus tels qu'ils sont, dans un ordre partiel, sans supprimer aucun élément.

Minable

Min-heap est l'inverse de max-heap.

File d'attente prioritaire en java propre

Java a une classe appelée PriorityQueue, pour Priority-Quye. Il a de nombreux constructeurs et méthodes. Seuls trois constructeurs et les méthodes les plus appropriées sont expliquées ci-dessous:

Construction Java d'une file d'attente prioritaire

Public PriorityQueue ()

Cela crée une file d'attente prioritaire sans aucun élément. La classe, PriorityQueue, est dans le java.user.* package, qui doit être importé. Le segment de code suivant crée une PriorityQueue vide, puis ajoute des valeurs non triées (pas même partiellement triées) à la file d'attente:

File d'attente de priorité pq = nouvelle priorityqueue();
pq.ajouter (69); pq.ajouter (65); pq.ajouter (87); pq.ajouter (79);
pq.ajouter (73); pq.ajouter (84); pq.ajouter (89); pq.ajouter (80);
pq.ajouter (81); pq.ajouter (82); pq.ajouter (85);

Ces nombres sont tous des entiers. Ils proviennent de la liste partiellement triée ci-dessus, mais actuellement, ils sont complètement non triés lorsqu'ils sont entrés. Les éléments de PQ sont désormais partiellement triés en fonction de la définition de la file d'attente prioritaire en Java.

PriorityQueue Priority (priorityqueue c)

Cela crée une priorité. Le segment de code suivant l'illustre:

File d'attente de priorité pq = nouvelle priorityqueue();
pq.ajouter (69); pq.ajouter (65); pq.ajouter (87); pq.ajouter (79);
pq.ajouter (73); pq.ajouter (84); pq.ajouter (89); pq.ajouter (80);
pq.ajouter (81); pq.ajouter (82); pq.ajouter (85);
File d'attente de priorité PQ1 = Nouvelle prioritaire(pq);

PQ1 a été créé à partir de PQ. Il a actuellement le même ordre partiel et PQ.

La troisième méthode du constructeur est illustrée ci-dessous.

Méthodes Java d'une file d'attente prioritaire

Public int size ()

Cela renvoie la taille de la liste et n'inclut pas les cellules vides, comme illustré dans le code suivant:

File d'attente de priorité pq = nouvelle priorityqueue();
pq.ajouter (69); pq.ajouter (65); pq.ajouter (87); pq.ajouter (79);
pq.ajouter (73); pq.ajouter (84); pq.ajouter (89); pq.ajouter (80);
pq.ajouter (81); pq.ajouter (82); pq.ajouter (85);
int sz = pq.taille();
Système.dehors.println (sz);

La sortie est 11.

Public Void Forach (Action des consommateurs)

Cette méthode doit être utilisée de manière spéciale pour copier toutes les valeurs dans la file d'attente prioritaire dans le formulaire partiellement trié. Le programme suivant illustre ceci:

File d'attente de priorité pq = nouvelle priorityqueue();
pq.ajouter (69); pq.ajouter (65); pq.ajouter (87); pq.ajouter (79);
pq.ajouter (73); pq.ajouter (84); pq.ajouter (89); pq.ajouter (80);
pq.ajouter (81); pq.ajouter (82); pq.ajouter (85);
pq.foreach (article -> système.dehors.print (item + ""));
Système.dehors.println ();

Notez la façon dont le code entre les parenthèses de la méthode foreach a été réalisé. L'élément est une variable factice qui représente chaque élément de la file d'attente. Notez l'utilisation de l'opérateur de flèches. La sortie est:

65 69 84 79 73 87 89 80 81 82 85

La sortie est correcte, dans un ordre partiel, mais dans un ordre croissant. Ce n'est pas nécessairement l'ordre inverse donné ci-dessus en raison de la manière dont les valeurs ont été incluses dans la liste. C'est-à-dire que la méthode foreach renvoie la liste comme un min-heap. Pour retourner la liste par ordre décroissant, utilisez le constructeur suivant:

PriorityQueue Priority (comparateur du comparateur)

C'est un constructeur. Le code suivant montre comment l'utiliser:

File d'attente de priorité pq = nouvelle priorityqueue((x, y) -> entier.comparer (y, x));
pq.ajouter (69); pq.ajouter (65); pq.ajouter (87); pq.ajouter (79);
pq.ajouter (73); pq.ajouter (84); pq.ajouter (89); pq.ajouter (80);
pq.ajouter (81); pq.ajouter (82); pq.ajouter (85);
pq.foreach (article -> système.dehors.print (item + ""));

Les x, y sont des variables muettes représentant le moindre et moins les valeurs. Notez que dans les premières parenthèses pour x et y, x vient avant y. Dans les seconds parenthèses, y vient avant x. La sortie est:

89 85 87 80 82 69 84 65 79 73 81

Public Boolean Add (E E)

Le nombre d'éléments dans une file d'attente prioritaire peut être augmenté un par un. Cette méthode renvoie vrai si un changement a eu lieu; et faux sinon. Le code suivant ajoute la douzième valeur pratique à la file d'attente:

File d'attente de priorité pq = nouvelle priorityqueue((x, y) -> entier.comparer (y, x));
pq.ajouter (69); pq.ajouter (65); pq.ajouter (87); pq.ajouter (79);
pq.ajouter (73); pq.ajouter (84); pq.ajouter (89); pq.ajouter (80);
pq.ajouter (81); pq.ajouter (82); pq.ajouter (85); pq.ajouter (70);
pq.foreach (article -> système.dehors.print (item + ""));

La valeur ajoutée augmenterait la file d'attente pour s'adapter à sa position appropriée, conduisant à une certaine réajustement des positions d'élément. La sortie est:

89 85 87 80 82 70 84 65 79 73 81 69

Public E Poll ()

Cette méthode récupère et supprime la tête de la file d'attente; ou renvoie nul, si cette file d'attente est vide. Chaque fois que la tête est supprimée, la file d'attente prioritaire se réajuste pour avoir une nouvelle tête légitime. Si la tête continue d'être supprimée, les valeurs renvoyées seront dans l'ordre trié complet. Le code suivant illustre ceci:

File d'attente de priorité pq = nouvelle priorityqueue((x, y) -> entier.comparer (y, x));
pq.ajouter (69); pq.ajouter (65); pq.ajouter (87); pq.ajouter (79);
pq.ajouter (73); pq.ajouter (84); pq.ajouter (89); pq.ajouter (80);
pq.ajouter (81); pq.ajouter (82); pq.ajouter (85); pq.ajouter (70);
pq.foreach (article -> système.dehors.Imprimer (PQ.Poll () + ""));

La sortie de l'ordinateur de l'auteur est:

89 87 85 84 82 81 80 79 73 70 69 65 Exception dans le thread "Main" Java.user.ConcurrentModificationException
à Java.base / java.user.File d'attente de priorité.foreach (priorityqueue.Java: 984)
à la classe.Main (Theclass.Java: 11)

Notez que la sortie est d'une commande triée complète. Ce code particulier n'a pas pu prendre l'exception jetée. Ce problème est laissé comme un exercice de recherche pour le lecteur.

Conclusion

Une file d'attente prioritaire en Java est une file d'attente dans laquelle les éléments ont une priorité autre que FIFO. Une file d'attente prioritaire est généralement un tas, qui peut être un maximum de tas ou un minimum. Les valeurs doivent être du même type. Ils sont stockés dans la file d'attente au format de tas (commande partielle). Nous espérons que vous avez trouvé cet article utile. Consultez les autres articles sur les conseils pour les conseils et les tutoriels.