数据结构之队列（优先队列）

概念

优先队列（Priority Queue）为一种不必遵守队列特性FIFO（先进先出）的有序线性表，其中每个元素都赋予一个优先级（Priority），加入元素时可任意加入，但有最高优先级者（Highest Priority Out First HPOF）则最先输出。

 

Java

在Java中，PriorityQueue 类实现了这样的一种有序队列。

PriorityQueue 是一个基于优先堆的无界优先队列。堆是一种特殊的树形数据结构，它满足以下两个条件：

• 父节点的值总是大于或等于子节点的值
• 每个节点的左子树和右子树也是一个堆

PriorityQueue 的主要方法包括：

• add(E e)：将指定的元素插入此优先队列。
• offer(E e)：将指定的元素插入此优先队列。
• remove()：获取并移除此队列的头，如果此队列为空，则返回 null 。
• poll(): 获取并移除此队列的头，如果此队列为空，则返回 null 。
• element()：获取但不移除此队列的头，如果此队列为空，则抛出一个 NoSuchElementException 异常。
• peek()：获取但不移除此队列的头，如果此队列为空，则返回 null 。

创建 PriorityQueue 可传入一个 Comparator 对象，该对象用来对元素进行排序。Comparator 接口中只有一个方法 compare()，在 PriorityQueue 中决定元素的顺序：

?

1	int compare(T o1, T o2)

该方法返回一个负整数、零或正整数，表示 o1 按照某种特定的顺序小于、等于或大于 o2。

import java.util.Comparator;
import java.util.PriorityQueue;

public class PriorityQueueExample {
    public static void main(String[] args) {
        // 创建一个自然排序的 PriorityQueue
        PriorityQueue<Integer> numbers = new PriorityQueue<>(new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                return o1.compareTo(o2);
            }
        });

        // 添加元素
        numbers.add(4);
        numbers.add(2);
        numbers.add(5);
        numbers.add(1);
        numbers.add(3);

        System.out.println("Priority Queue: " + numbers);

        // 获取队列头部的元素
        int peek = numbers.peek();
        System.out.println("队列头部的元素是：" + peek);

        // 删除队列头部的元素
        int poll = numbers.poll();
        System.out.println("删除的元素是：" + poll);

        System.out.println("新的 Priority Queue: " + numbers);
        // 队列中元素的存储顺序，与出队顺序不一定一致
        while (!numbers.isEmpty()){
            // 删除队列头部的元素
            System.out.println("删除的元素是：" + numbers.poll());

        }
    }
}

输出：

?

1 2 3 4 5 6 7 8

Priority Queue: [1, 2, 5, 4, 3] 队列头部的元素是：1 删除的元素是：1 新的 Priority Queue: [2, 3, 5, 4] 删除的元素是：2 删除的元素是：3 删除的元素是：4 删除的元素是：5

　　

Python

在Python中，我们可以使用heapq模块来实现优先队列。

import heapq

# 初始化一个空堆结构
h = []

# 加入元素
heapq.heappush(h, 5)
heapq.heappush(h, 7)
heapq.heappush(h, 3)

# 弹出并返回最小的元素
print(heapq.heappop(h))  # 3

# 查看最小的元素，不弹出
print(h[0])  # 5

# 弹出后打印，以此类推，直到为空
while h:
    print(heapq.heappop(h))  # 5 7

输出：

?

1 2 3 4

1 3 3 5

　　

通过heappop方法你会按照从小到大依次取出值。

 

列表转换堆

import heapq

h = []
# heapq._heapify_max(h)  # 将list h 转换为最大堆.最大堆（MaxHeap）根节点的值最大，每个父节点的值都比子节点的值要大
heapq.heapify(h)  # 将list h 转换为最大堆.最大堆（MaxHeap）根节点的值最大，每个父节点的值都比子节点的值要大

heapq.heappush(h, 1)
heapq.heappush(h, 3)
heapq.heappush(h, 5)

print(heapq.heappop(h))  # 1
print(h[0])  # 3

while h:
    print(heapq.heappop(h))  # 3 5

输出：

?

1 2 3 4

1 3 3 5

　　

Javascript

class PriorityQueue {
    constructor() {
        this.items = [];
    }

    enqueue(element) {
        if (this.isEmpty()) {
            this.items.push(element);
        } else {
            let added = false;
            for (let i = 0; i < this.items.length; i++) {
                if (element.priority < this.items[i].priority) {
                    this.items.splice(i, 0, element);
                    added = true;
                    break;
                }else if(element.priority==undefined && element < this.items[i]){
                    this.items.splice(i, 0, element);
                    added = true;
                    break;
                }
            }
            if (!added) {
                this.items.push(element);
            }
        }
    }

    dequeue() {
        return this.items.shift();
    }

    isEmpty() {
        return this.items.length === 0;
    }
}

queue =new PriorityQueue()
queue.enqueue(2)
queue.enqueue(1)
queue.enqueue(9)
queue.enqueue(8)
console.log(queue)
while (!queue.isEmpty()){
    console.log(queue.dequeue())
}

输出：

?

1 2 3 4 5

PriorityQueue { items: [ 1, 2, 8, 9 ] } 1 2 8 9