文章目录
一、概述
普通的队列是一种先进先出的数据结构，元素在队列尾追加，而从队列头删除。在某些情况下，我们可能需要找出队列中的最大值或者最小值，例如使用一个队列保存计算机的任务，一般情况下计算机的任务都是有优先级的，我们需要在这些计算机的任务中找出优先级最高的任务先执行，执行完毕后就需要把这个任务从队列中移除。普通的队列要完成这样的功能，需要每次遍历队列中的所有元素，比较并找出最大值，效率不是很高，这个时候，我们就可以使用一种特殊的队列来完成这种需求，优先队列。
实现思路： 数组、有序数组、链表、有序链表、二叉查找树、堆
二、最大优先队列
概述：可以获取并删除队列中最大的值
最大优先队列代码
public class MaxPriorityQueue<T extends Comparable> {
// 存储堆中的元素
private T[] items;
// 记录堆中元素的个数
private int N;
public MaxPriorityQueue(int capacity) {
items = (T[]) new Comparable[capacity + 1];
N = 0;
}
public T delMax() {
T max = items[1];
exch(1, N);
items[N] = null;
N--;
sink(1);
return max;
}
private void sink(int k) {
while (2 * k <= N) {
int max = 2 * k;
if (2 * k + 1 <= N) {
if (less(2 * k, 2 * k + 1)) {
max = 2 * k + 1;
}
}
if (!less(k, max)) {
break;
}
exch(k, max);
k = max;
}
}
public void insert(T t) {
items[++N] = t;
swim(N);
}
// 上浮
private void swim(int k) {
while (k > 1) {
if (less(k / 2, k)) {
exch(k / 2, k);
}
k = k / 2;
}
}
private boolean less(int i, int j) {
return items[i].compareTo(items[j]) < 0;
}
private void exch(int i, int j) {
T tmp = items[i];
items[i] = items[j];
items[j] = tmp;
}
public int size() {
return N;
}
public boolean isEmpty() {
return N == 0;
}
}
测试代码
public static void main(String[] args) {
String[] arr = {"S", "O", "R", "T", "E", "X", "A", "M", "P", "L", "E"};
MaxPriorityQueue<String> maxpq = new MaxPriorityQueue<>(20);
for (String s : arr) {
maxpq.insert(s);
}
System.out.println(maxpq.size());
String del;
while (!maxpq.isEmpty()) {
del = maxpq.delMax();
System.out.print(del + ",");
}
}
三、最小优先队列
可以获取并删除队列中最小的值
最小优先队列代码
public class MinPriorityQueue<T extends Comparable> {
private T[] items;
private int N;
public MinPriorityQueue(int capacity) {
items = (T[]) new Comparable[capacity + 1];
N = 0;
}
public T delMin() {
T min = items[1];
exch(1, N);
items[N] = null;
N--;
sink(1);
return min;
}
private void exch(int i, int j) {
T tmp = items[i];
items[i] = items[j];
items[j] = tmp;
}
// 下沉
private void sink(int k) {
while (2 * k <= N) {
int min = 2 * k;
if (2 * k + 1 <= N && less(2 * k + 1, 2 * k)) {
min = 2 * k + 1;
}
if (less(k, min)) {
break;
}
exch(min, k);
k = min;
}
}
private boolean less(int i, int j) {
return items[i].compareTo(items[j]) < 0;
}
public void insert(T t) {
items[++N] = t;
swim(N);
}
// 上浮
private void swim(int k) {
while (k > 1) {
if (less(k, k / 2)) {
exch(k, k / 2);
}
k = k / 2;
}
}
public int size() {
return N;
}
public boolean isEmpty() {
return N == 0;
}
}
测试代码
public static void main(String[] args) {
String[] arr = {"S", "O", "R", "T", "E", "X", "A", "M", "P", "L", "E"};
MinPriorityQueue<String> minpq = new MinPriorityQueue<>(20);
for (String s : arr) {
minpq.insert(s);
}
System.out.println(minpq.size());
String del;
while (!minpq.isEmpty()) {
del = minpq.delMin();
System.out.print(del + ",");
}
}
四、索引优先队列
解决的问题：最大最小优先队列无法查找到指定的元素并修改
索引优先队列代码
public class IndexMinPriorityQueue<T extends Comparable> {
private T[] items;
private int[] pq; // 保存每个元素在items数组中的索引，需要堆有序
private int[] qp; // 为了提高查询item索引的效率
private int N;
public IndexMinPriorityQueue(int capacity) {
this.items = (T[]) new Comparable[capacity + 1];
this.pq = new int[capacity + 1];
this.qp = new int[capacity + 1];
this.N = 0;
// 默认队列中没有存储任何数据，让qp中的元素都为-1
for (int i = 0; i < qp.length; i++) {
qp[i] = -1;
}
}
// 删除队列中最小的元素，并返回该元素关联的索引
public int delMin() {
// 找到items中最小元素的索引
int minIndex = pq[1];
// 交换pq中索引1处的值和N处的值
exch(1, N);
// 删除pq中索引pq[N]处的值
qp[pq[N]] = -1;
// 删除pq中索引N处的值
pq[N] = -1;
// 删除items中的最小元素
items[minIndex] = null;
// 元素数量-1
N--;
// 对pq[1]做下沉，让堆有序
sink(1);
return minIndex;
}
// 下沉
private void sink(int k) {
// 如果当前节点已经没有子节点了，则结束下沉
while (2 * k <= N) {
// 找出子节点中的较小值
int min = 2 * k;
if (2 * k + 1 <= N && less(2 * k + 1, 2 * k)) {
min = 2 * k + 1;
}
//如果当前节点的值比子节点中的较小值小，则结束下沉
if (less(k, min)) {
break;
}
exch(k, min);
k = min;
}
}
public void insert(int i, T t) {
if (contains(i)) {
throw new RuntimeException("该索引已经存在");
}
N++;
// 把元素放到items数组中
items[i] = t;
// 使用pq存放i这个索引
pq[N] = i;
// 在qp的i索引处存放N
qp[i] = N;
// 上浮items[pq[N]]，让pq堆有序
swim(N);
}
// 上浮
private void swim(int k) {
// 如果已经到了根节点，则结束上浮
while (k > 1) {
if (less(k, k / 2)) {
exch(k, k / 2);
}
k = k / 2;
}
}
private boolean less(int i, int j) {
return items[pq[i]].compareTo(items[pq[j]]) < 0;
}
private void exch(int i, int j) {
int tmp = pq[i];
pq[i] = pq[j];
pq[j] = tmp;
//更新qp中的数据
qp[pq[i]]=i;
qp[pq[j]] =j;
}
public int size() {
return N;
}
public boolean isEmpty() {
return N == 0;
}
// 判断
public boolean contains(int k) {
return qp[k] != -1;
}
// 通过索引访问已存在于优先队列中的对象，并更新它们
public void changeItem(int i, T t) {
// 修改items数组中索引i处的值为t
items[i] = t;
// 找到i在pq中的位置
int k = qp[i];
// 对pq[k]做下沉，让堆有序
sink(k);
// 堆pq[k]做上浮，让堆有序
swim(k);
}
// 最小元素关联的索引
public int minIndex() {
return pq[1];
}
// 删除索引i关联的元素
public void delete(int i) {
// 找出i在pq中的索引
int k = qp[i];
// 把pq中索引k处的值和索引N处的值交换
exch(k, N);
// 删除qp中索引pq[N]处的值
qp[pq[N]] = -1;
// 删除items中索引i处的值
items[i] = null;
// 元素数量-1
N--;
// 对pq[k]做下沉，让堆有序
sink(k);
// 对pq[k]做上浮，让堆有序
swim(k);
}
}
测试代码
public static void main(String[] args) {
String[] arr = {"S", "O", "R", "T", "E", "X", "A", "M", "P", "L", "E"};
IndexMinPriorityQueue<String> indexMinPQ = new IndexMinPriorityQueue<>(20);
//插入
for (int i = 0; i < arr.length; i++) {
indexMinPQ.insert(i, arr[i]);
}
System.out.println(indexMinPQ.size());
//获取最小值的索引
System.out.println(indexMinPQ.minIndex());
//测试修改
indexMinPQ.changeItem(0, "Z");
int minIndex = -1;
while (!indexMinPQ.isEmpty()) {
minIndex = indexMinPQ.delMin();
System.out.print(minIndex + ",");
}
}