当前位置：
  1. 首页
  2. 后端开发
  3. Java
  4. 正文

Java 最大优先级队列

Java 12

优先级队列是 java 中的一种数据结构，其中元素根据其自然状态存在，而不是根据先进先出的顺序。元素也可以根据优先队列中使用的比较器进行排序。

本教程演示了优先级队列的使用以及如何从优先级队列中获取最大值。

Java 中优先级队列的使用

如上所述，元素以其自然状态存在于优先级队列中。让我们看一个例子。

代码：

package delftstack;
import java.util.*;
public class Priority_Queue{
    public static void main(String args[]){
        PriorityQueue<String> delftstack_queue=new PriorityQueue<String>();
        //Add the values to the priority queue
        delftstack_queue.add("delftstack3");
        delftstack_queue.add("delftstack2");
        delftstack_queue.add("delftstack1");
        delftstack_queue.add("delftstack4");
        delftstack_queue.add("delftstack5");
        delftstack_queue.add("delftstack6");
        //head of the PriorityQueue
        System.out.println("Head of the PriorityQueue, The minimum value: "+delftstack_queue.element());
        //All Elements of the Priority Queue
        System.out.println("\nAll PriorityQueue Elements:");
        Iterator demo_iterator=delftstack_queue.iterator();
        while(demo_iterator.hasNext()){
            System.out.print(demo_iterator.next() + " ");
        }
    }
}

上面的代码将首先打印优先级队列的头部，这将是最小值，并打印所有元素。

输出：

Head of the PriorityQueue, The minimum value: delftstack1
All PriorityQueue Elements:
delftstack1 delftstack3 delftstack2 delftstack4 delftstack5 delftstack6

正如我们所看到的，头部是最小值。接下来，我们将演示如何从 Java 中的优先级队列中获取最大值。

从 Java 中的优先级队列中获取最大值

要从优先级队列中获取最大值，我们应该首先按照降序对它们进行排序。要按降序对元素进行排序，我们可以使用比较器从 JAVA 中的优先级队列中获取最大值。

例子：

package delftstack;
import java.util.*;
public class Priority_Queue{
    public static void main(String args[]){
        //Initialize a priority queue with a custom comparator to sort the queue in descending order.
        PriorityQueue<Integer> demo_priority_queue = new PriorityQueue<Integer>(new Comparator<Integer>() {
            public int compare(Integer left_hand_side, Integer right_hand_side) {
                if (left_hand_side < right_hand_side) return +1;
                if (left_hand_side.equals(right_hand_side)) return 0;
                    return -1;
            }
        });
        //add elements
        demo_priority_queue.add(11);
        demo_priority_queue.add(7);
        demo_priority_queue.add(3);
        demo_priority_queue.add(18);
        demo_priority_queue.add(10);
        demo_priority_queue.add(2);
        demo_priority_queue.add(17);
        demo_priority_queue.add(20);
        demo_priority_queue.add(5);
        //display the max PriorityQueue
        System.out.println("The Priority Queue elements in max to min order:");
        Integer val = null;
        while( (val = demo_priority_queue.poll()) != null) {
            System.out.print(val + " ");
        }
    }
}

上面的代码对优先级队列进行降序排序以获得最大值。

输出：

The Priority Queue elements in max to min order:
20 18 17 11 10 7 5 3 2

这里有更多按降序对优先级队列进行排序以获得最大值的方法。

例子：

package delftstack;
import java.util.*;
public class Priority_Queue{
    public static void main(String args[]){
        //Initialize a priority queue with a custom comparator to sort the queue in descending order.
        PriorityQueue<Integer> demo_priority_queue = new PriorityQueue<Integer>(Collections.reverseOrder());
        //PriorityQueue<Integer> demo_priority_queue = new PriorityQueue<Integer>((a,b) -> b - a);
        //PriorityQueue<Integer> demo_priority_queue = new PriorityQueue<Integer>((a,b) -> b.compareTo(a));
        //add elements
        demo_priority_queue.add(11);
        demo_priority_queue.add(7);
        demo_priority_queue.add(3);
        demo_priority_queue.add(18);
        demo_priority_queue.add(10);
        demo_priority_queue.add(2);
        demo_priority_queue.add(17);
        demo_priority_queue.add(20);
        demo_priority_queue.add(5);
        //display the max PriorityQueue
        System.out.println("The Priority Queue elements in max to min order:");
        Integer val = null;
        while( (val = demo_priority_queue.poll()) != null) {
            System.out.print(val + " ");
        }
    }
}

Collections.reverseOrder() 是一个内置的比较器，用于按降序对优先级队列进行排序。注释中的其他两个比较器也执行相同的操作，我们可以使用它们中的任何一个。

输出：

The Priority Queue elements in max to min order:
20 18 17 11 10 7 5 3 2

手动比较器和内置比较器的区别在于，我们还可以使用内置比较器对字符串进行排序，并得到最大值，如下面的代码片段。

例子：

package delftstack;
import java.util.*;
public class Priority_Queue{
    public static void main(String args[]){
        PriorityQueue<String> delftstack_queue=new PriorityQueue<String>(Collections.reverseOrder());
        //Add the values to the priority queue
        delftstack_queue.add("delftstack3");
        delftstack_queue.add("delftstack2");
        delftstack_queue.add("delftstack1");
        delftstack_queue.add("delftstack4");
        delftstack_queue.add("delftstack5");
        delftstack_queue.add("delftstack6");
        //head of the PriorityQueue
        System.out.println("Head of the PriorityQueue, The maximum value: "+delftstack_queue.element());
        //All Elements of the Priority Queue
        System.out.println("\nAll PriorityQueue Elements:");
        Iterator demo_iterator=delftstack_queue.iterator();
        while(demo_iterator.hasNext()){
            System.out.print(demo_iterator.next() + " ");
        }
    }
}

输出：

Head of the PriorityQueue, The maximum value: delftstack6
All PriorityQueue Elements:
delftstack6 delftstack4 delftstack5 delftstack2 delftstack3 delftstack1
上一篇 Java 中的优先队列
下一篇 Java 中的制表符

相关文章

    当前位置：
  1. 首页
  2. 前端开发
  3. JavaScript
  4. 正文

JavaScript 中的优先级队列

JavaScript 8

在 JavaScript 中，优先级队列是一种向队列添加优先级维度的数据结构。队列按照到达的顺序列出取走的物品。

例如，在药店排队等候药品的人的行为类似于队列：FIFO（先进先出）。优先级队列为每个项目的值添加一个优先级。

如果 PQ 的所有元素具有相同的优先级，则它的行为类似于常规队列。今天的文章将教我们如何在 JavaScript 中实现优先级队列。

JavaScript 中的优先级队列

Priority Queue 是一个简单的队列，具有如下高级属性。

 

  1. 优先级队列中的每个项目都有一个与之关联的优先级。
  2. 根据优先级将项目添加到队列中。
  3. 优先级较低的项目首先被删除。
  4. 优先级队列可以使用两种方法设计：第一种情况，我们可以在队列末尾添加队列项，并根据优先级从队列中删除项。在第二种情况下，我们可以根据优先级将项目添加到队列中，并从头开始将它们从队列中移除。

示例代码：

class QueueElement {
    constructor(element, priority) {
        this.element = element;
        this.priority = priority;
    }
}
class PriorityQueue {
    constructor() {
        this.queueItems = [];
    }
    enqueueFunction(element, priority) {
        let queueElement = new QueueElement(element, priority);
        let contain = false;

        for (let i = 0; i < this.queueItems.length; i++) {
            if (this.queueItems[i].priority > queueElement.priority) {
                this.queueItems.splice(i, 0, queueElement);
                contain = true;
                break;
            }
        }
        /* if the input element has the highest priority push it to end of the queue */
        if (!contain) {
            this.queueItems.push(queueElement);
        }
    }
    dequeueFunction() {
        /* returns the removed element from priority queue. */
        if (this.isPriorityQueueEmpty()) {
            return "No elements present in Queue";
        }
        return this.queueItems.shift();
    }
    front() {
        /* returns the highest priority queue element without removing it. */
        if (this.isPriorityQueueEmpty()) {
            return "No elements present in Queue";
        }
        return this.queueItems[0];
    }
    rear() {
        /* returns the lowest priority queue element without removing it. */
        if (this.isPriorityQueueEmpty()) {
            return "No elements present in Queue";
        }
        return this.queueItems[this.queueItems.length - 1];
    }
    isPriorityQueueEmpty() {
        /* Checks the length of an queue */
        return this.queueItems.length === 0;
    }
    /* prints all the elements of the priority queue */
    printPriorityQueue() {
        let queueString = "";
        for (let i = 0; i < this.queueItems.length; i++)
            queueString += this.queueItems[i].element + " ";
        return queueString;
    }
}

在上面的示例中，我们定义了 PriorityQueue 类的框架。我们使用了一个自定义的 QueueElement 类，其中包含两个 Property 和 Priority 元素。

我们在 PriorityQueue 类中使用了一个数组来实现优先队列，这个数组是 QueueElement 的容器。我们将 1 视为最高优先级项目，你可以根据自己的要求进行更改。

  1. enqueueFunction()：在这个方法中，我们创建一个带有元素属性和优先级的 queueElement。然后我们遍历队列以根据其优先级找到 queueElement 的正确位置，并根据其优先级将元素添加到队列中。
  2. dequeueFunction()：该函数从队列的前面移除一个元素，因为具有最高优先级的元素存储在优先级队列的前面。我们使用修改后的数组方法将元素出列。
  3. front()：该函数返回优先队列的最前面的元素。我们返回数组的元素 0 以获取优先级队列的开始。
  4. rear()：此函数返回队列中的最后一项或具有最低优先级的项。
  5. isPriorityQueueEmpty()：我们使用数组的 length 属性来获取长度，如果为 0，则优先队列为空。
  6. printPriorityQueue()：在此方法中，我们将优先级队列中每个项目的项目属性连接成一个字符串。根据优先级打印队列中的项目，从最高到最低

现在让我们使用优先队列的第一个代码示例并尝试上面描述的不同方法。

示例代码：

let priorityQueue = new PriorityQueue();
console.log(priorityQueue.isPriorityQueueEmpty());

console.log(priorityQueue.front());

priorityQueue.enqueueFunction("Sonya", 2);
priorityQueue.enqueueFunction("John", 1);
priorityQueue.enqueueFunction("Alma", 1);
priorityQueue.enqueueFunction("Alexander", 2);
priorityQueue.enqueueFunction("Arthur", 3);

console.log(priorityQueue.printPriorityQueue());
console.log(priorityQueue.front().element);
console.log(priorityQueue.rear().element);
console.log(priorityQueue.dequeueFunction().element);

priorityQueue.enqueueFunction("Harold", 2);
console.log(priorityQueue.printPriorityQueue());

输出：

true
"No elements present in Queue"
"John Alma Sonya Alexander Arthur "
"John"
"Arthur"
"John"
"Alma Sonya Alexander Harold Arthur "
上一篇 如何在 JavaScript 中重置表单
下一篇 JavaScript 中的拼接与切片

相关文章