优先队列

算法思想

---

1. 数据结构：一个队列
2. 支持操作：
   • 删除最大元素
   • 插入元素

Java

---

• 源码

// 基于堆的优先队列
public class MaxPQ<Key extends Comparable<Key>> {
    private Key[] pq;// 基于堆的完全二叉树
    private int N = 0;// 存储于pq[1..N]中，pq[0]没有使用

    public MaxPQ(int maxN) {
        pq = (Key[]) new Comparable[maxN + 1];
    }

    public boolean isEmpty() {
        return N == 0;
    }

    public int size() {
        return N;
    }

    public void insert(Key v) {
        pq[++N] = v;
        swim(N);
    }

    public Key delMax() {
        Key max = pq[1];// 从根结点得到最大元素
        exch(1, N--);// 将其和最后一个结点交换
        pq[N + 1] = null;// 防止越界
        sink(1);// 恢复堆的有序性
        return max;
    }

    // 堆实现的比较方法
    private boolean less(int i, int j) {
        return pq[i].compareTo(pq[j]) < 0;
    }

    // 堆实现的交换方法
    private void exch(int i, int j) {
        Key t = pq[i];
        pq[i] = pq[j];
        pq[j] = t;
    }

    // 由下至上的堆有序化
    private void swim(int k) {
        while (k > 1 && less(k / 2, k)) {
            exch(k / 2, k);
            k = k / 2;
        }
    }

    // 由上至下的堆有序化
    private void sink(int k) {
        while (2 * k <= N) {
            int j = 2 * k;
            if (j < N && less(j, j + 1)) j++;
            if (!less(k, j)) break;
            exch(k, j);
            k = j;
        }
    }
}

• 测试用例

import java.util.ArrayList;
import java.util.List;

public class Test {
    public static void main(String[] args) {
        int max = 4;// 设置队列的最大值为4，队列长度多于max，则出队列
        List<String> test = new ArrayList<String>() {
            {
                add("Turing");
                add("vonNeumann");
                add("Dijkstra");
                add("Hoare");
                add("vonNeumann");
                add("Hoare");
                add("Turing");
                add("Thompson");
                add("Turing");
                add("Hoare");
                add("vonNeumann");
                add("Dijkstra");
                add("Turing");
                add("Hoare");
            }
        };

        MaxPQ<String> maxPQ = new MaxPQ<>(max);
        for (String s : test) {
            maxPQ.insert(s);
            if (maxPQ.size() >= max) System.out.println(maxPQ.delMax());
        }
        while (maxPQ.size() > 0) {
            System.out.println(maxPQ.delMax());
        }
    }
}

• 测试结果

vonNeumann
vonNeumann
Turing
Turing
Thompson
Turing
Hoare
vonNeumann
Hoare
Turing
Hoare
Hoare
Dijkstra
Dijkstra