文章目录
普通的队列是一种先进先出的数据结构，元素在队列尾追加，而从队列头删除。在某些情况下，我们可能需要找出队列中的最大值或者最小值，例如使用一个队列保存计算机的任务，一般情况下计算机的任务都是有优先级的，我们需要在这些计算机的任务中找出优先级最高的任务先执行，执行完毕后就需要把这个任务从队列中移除。普通的队列要完成这样的功能，需要每次遍历队列中的所有元素，比较并找出最大值，效率不是很高，这个时候，我们就可以使用一种特殊的队列来完成这种需求，优先队列。
优先队列按照其作用不同，可以分为以下两种：
- 最大优先队列：可以获取并删除队列中最大的值
- 最小优先队列：可以获取并删除队列中最小的值
1 最大优先队列
我们之前学习过堆，而堆这种结构是可以方便的删除最大的值，所以，接下来我们可以基于堆区实现最大优先队列。
1.1 最大优先队列API设计
1.2 最大优先级队列代码实现
/**
* 最大有优先级队列
* 用堆实现
*/
public class MaxPriorityQueue<T extends Comparable<T>> {
//定义一个数组存储堆中元素
private T[] items;
//存储堆中元素个数
private int N;
//构造函数初始化参数
public MaxPriorityQueue(int capacity) {
items = (T[]) new Comparable[capacity + 1];
this.N = 0;
}
//队列中元素个数
public int size() {
return N;
}
//队列是否为空
public boolean isEmpty() {
return N == 0;
}
//队列插入元素
public void insert(T t) {
//最大索引处增加元素并递增
items[++N] = t;
//上浮元素至正确位置
swim(N);
}
//队列插入元素后上浮，使其处于一个正确的位置
public void swim(int k) {
while (k > 1) {
if (less(k / 2, k)) {
exch(k / 2, k);
}
k = k / 2;
}
}
//删除最大元素,并返回这个元素
public T delMax() {
T max = items[1];
//交换最大元素和最后一个元素位置
exch(1, N);
//删除最后一个元素
items[N] = null;
N--;
//下沉元素1处元素至正确位置
sink(1);
return max;
}
//删除元素后下沉
public void sink(int k) {
while (2 * k <= N) {
int max;
//如果有右子节点
if (2 * k + 1 <= N) {
if (less(2 * k + 1, 2 * k)) {
max = 2 * k;
} else {
max = 2 * k + 1;
}
} else {
max = 2 * k;
}
if (!less(k, max)) {
break;
}
exch(k, max);
k = max;
}
}
//比较元素大小
public boolean less(int i, int j) {
return items[i].compareTo(items[j]) < 0;
}
//交换元素
public void exch(int i, int j) {
T temp = items[i];
items[i] = items[j];
items[j] = temp;
}
public static void main(String[] args) {
//创建最小优先队列对象
MaxPriorityQueue<String> queue = new MaxPriorityQueue<>(10);
//往队列中存数据
queue.insert("G");
queue.insert("F");
queue.insert("E");
queue.insert("D");
queue.insert("C");
queue.insert("B");
queue.insert("A");
//通过循环获取最小优先队列中的元素
while (!queue.isEmpty()) {
String min = queue.delMax();
System.out.print(min + " ");
}
}
}
2 最小优先队列
最小优先队列实现起来也比较简单，我们同样也可以基于堆来完成最小优先队列。我们前面学习堆的时候，堆中存放数据元素的数组要满足都满足如下特性：
- 最大的元素放在数组的索引1处。
- 每个结点的数据总是大于等于它的两个子结点的数据。
其实我们之前实现的堆可以把它叫做最大堆，我们可以用相反的思想实现最小堆，让堆中存放数据元素的数组满足如下特性：
- 最小的元素放在数组的索引1处。
- 每个结点的数据总是小于等于它的两个子结点的数据。
- 这样我们就能快速的访问到堆中最小的数据。
2.1 最小优先级队列API设计
2.2 最小优先级队列代码实现
/**
* 最小有优先级队列
* 用堆实现
*/
public class MinPriorityQueue<T extends Comparable<T>> {
//定义一个数组存储堆中元素
private T[] items;
//记录堆中元素个数
private int N;
//构造函数初始化参数
public MinPriorityQueue(int capacity) {
items = (T[]) new Comparable[capacity + 1];
this.N = 0;
}
//判断队列是否为空
public boolean isEmpty() {
return N == 0;
}
//获取队列中元素个数
public int size() {
return N;
}
//插入元素（最大索引处插入元素，上浮调整顺序）
public void insert(T t) {
items[++N] = t;
//上浮
swim(N);
}
//插入元素后上浮操作，使插入的k元素在堆中又一个正确的位置
public void swim(int k) {
//k和其父节点k/2比较
while (k > 1) {
if (less(k, k / 2)) {
exch(k, k / 2);
}
k = k / 2;
}
}
//删除最大元素
public T delMin() {
//取出最大元素，索引为1的
T minT = items[1];
//交换最大索引和1处元素
exch(1, N);
//删除最大索引处元素
items[N] = null;
//元素递减
N--;
//现在将索引为1的元素下沉，调整其到正确位置
sink(1);
return minT;
}
//删除最大小元素后下沉（最后一个元素和第一个元素交换）
public void sink(int k) {
while (2 * k <= N) {
//找出子节点中最大值
//如果有右子节点
int min;
if (2 * k + 1 <= N) {
if (less(2 * k, 2 * k + 1)) {
min = 2 * k;
} else {
min = 2 * k + 1;
}
} else {
min = 2 * k;
}
//判读啊当前节点和子节点值的大小
if (less(k, min)) {
break;
}
exch(k, min);
//索引指向子节点
k = min;
}
}
//比较元素大小
public boolean less(int i, int j) {
return items[i].compareTo(items[j]) < 0;
}
//交换元素位置
public void exch(int i, int j) {
T temp = items[i];
items[i] = items[j];
items[j] = temp;
}
public static void main(String[] args) {
//创建最小优先队列对象
MinPriorityQueue<String> queue = new MinPriorityQueue<>(10);
//往队列中存数据
queue.insert("G");
queue.insert("F");
queue.insert("E");
queue.insert("D");
queue.insert("C");
queue.insert("B");
queue.insert("A");
//通过循环获取最小优先队列中的元素
while (!queue.isEmpty()) {
String min = queue.delMin();
System.out.print(min + " ");
}
}
}
3 索引优先队列
在之前实现的最大优先队列和最小优先队列，他们可以分别快速访问到队列中最大元素和最小元素，但是他们有一个缺点，就是没有办法通过索引访问已存在于优先队列中的对象，并更新它们。为了实现这个目的，在优先队列的基础上，学习一种新的数据结构，索引优先队列。接下来我们以最小索引优先队列举列。
3.1 索引优先队列实现思路
步骤一：
存储数据时，给每一个数据元素关联一个整数，例如insert(int k,T t),我们可以看做k是t关联的整数，那么我们的实现需要通过k这个值，快速获取到队列中t这个元素，此时有个k这个值需要具有唯一性。
最直观的想法就是我们可以用一个T[] items数组来保存数据元素，在insert(int k,T t)完成插入时，可以把k看做是items数组的索引，把t元素放到items数组的索引k处，这样我们再根据k获取元素t时就很方便了，直接就可以拿到items[k]即可。
步骤二：
步骤一完成后的结果，虽然我们给每个元素关联了一个整数，并且可以使用这个整数快速的获取到该元素，但是，items数组中的元素顺序是随机的，并不是堆有序的，所以，为了完成这个需求，我们可以增加一个数组int[]pq,来保存每个元素在items数组中的索引，pq数组需要堆有序，也就是说，pq[1]对应的数据元素items[pq[1]]要小于等于pq[2]和pq[3]对应的数据元素items[pq[2]]和items[pq[3]]。
步骤三：
通过步骤二的分析，我们可以发现，其实我们通过上浮和下沉做堆调整的时候，其实调整的是pq数组。如果需要对items中的元素进行修改，比如让items[0]=“H”,那么很显然，我们需要对pq中的数据做堆调整，而且是调整pq[9]中元素的位置。但现在就会遇到一个问题，我们修改的是items数组中0索引处的值，如何才能快速的知道需要挑中pq[9]中元素的位置呢？最直观的想法就是遍历pq数组，拿出每一个元素和0做比较，如果当前元素是0，那么调整该索引处的元素即可，但是效率很低。我们可以另外增加一个数组，int[] qp,用来存储pq的逆序。例如：在pq数组中：pq[1]=6;那么在qp数组中，把6作为索引，1作为值，结果是：qp[6]=1;
当有了pq数组后，如果我们修改items[0]=“H”，那么就可以先通过索引0，在qp数组中找到qp的索引：qp[0]=9,那么直接调整pq[9]即可。
3.2 索引优先队列API设计
3.3 最小索引优先队列代码实现
/**
* 最小索引优先级队列
*/
public class IndexMinPriorityQueue<T extends Comparable<T>> {
//存储堆中元素
private T[] items;
//保存每个元素在items数组中的索引，pq数组需要堆有序
private int[] pq;
//保存pq的逆序，pq值作为索引，pq索引作为值
private int[] qp;
//记录堆中元素个数
private int N;
//构造函数
public IndexMinPriorityQueue(int capacity) {
items = (T[]) new Comparable[capacity + 1];
pq = new int[capacity + 1];
qp = new int[capacity + 1];
this.N = 0;
//默认队列不存储元素
for (int i = 0; i < qp.length; i++) {
qp[i] = -1;
}
}
//队列是否为空
public boolean isEmpty() {
return N == 0;
}
//队列大小
public int size() {
return N;
}
//比较大小
public boolean less(int i, int j) {
//pq索引处元素大小
return items[pq[i]].compareTo(items[pq[j]]) < 0;
}
//交换元素顺序
public void exch(int i, int j) {
//交换pq中索引顺序
int temp = pq[i];
pq[i] = pq[j];
pq[j] = temp;
//更新qp中数据
qp[pq[i]] = i;
qp[pq[j]] = j;
}
//判断k处索引是否已经存在
public boolean contain(int k) {
return qp[k] != -1;
}
//最小元素关联的索引
public int minIndex() {
return pq[1];
}
//索引i处插入元素t
public void insert(int i, T t) {
if (contain(i)) {
return;
}
//把数据存到items对应的i位置处
items[i] = t;
//元素个数加1
N++;
//把i存储到pq中
pq[N] = i;
//记录qp中逆序
qp[i] = N;
//通过上浮完成堆调整
swim(i);
}
//删除最小索引
public int delMin() {
//获取最小元素关联的索引
int minIndex = pq[1];
//交换pq索引处1和N处的元素
exch(1, N);
//删除逆索引
qp[pq[N]] = -1;
//删除pq中存储索引
pq[N] = -1;
//删除元素
items[minIndex] = null;
N--;
//下沉操作
sink(1);
return minIndex;
}
//删除指定索引
public void delete(int i) {
//i在pq处的索引
int k = qp[i];
//交换k和最后一个元素索引
exch(k, N);
//删除元素
items[k] = null;
//删除逆索引
qp[pq[N]] = -1;
//删除该索引
pq[N] = -1;
//堆的调整
sink(k);
swim(k);
}
//把与索引i关联的元素修改为t
public void changeItem(int i, T t) {
//修改items数组中i位置的元素为t
int k = qp[i];
//找到i在pq中出现的位置
items[k] = t;
//堆调整
swim(k);
sink(k);
}
//上浮
public void swim(int k) {
while (k > 1) {
if (less(k, k / 2)) {
exch(k, k / 2);
}
k = k / 2;
}
}
//下沉
public void sink(int k) {
while (2 * k < N) {
//找出子节点中最小元素索引
int min;
//如果存在右子节点
if (2 * k + 1 < N) {
if (less(2 * k + 1, 2 * k)) {
min = 2 * k + 1;
} else {
min = 2 * k;
}
} else {
min = 2 * k;
}
//如果比子节点大，则不用交换
if (!less(k, min)) {
break;
}
exch(k, min);
k = min;
}
}
public static void main(String[] args) {
//创建索引最小优先队列对象
IndexMinPriorityQueue<String> queue = new IndexMinPriorityQueue<>(10);
//往队列中添加元素
queue.insert(0, "A");
queue.insert(1, "C");
queue.insert(2, "F");
//测试修改
queue.changeItem(2, "B");
//测试删除
while (!queue.isEmpty()) {
int index = queue.delMin();
System.out.print(index + " ");
}
}
}
3.4 最大索引优先级队列实现
package com.bcl.algorithm.priority;
/**
* 索引最大优先级队列
*/
public class IndexMaxPriorityQueue<T extends Comparable<T>> {
//存储堆中元素
private T[] items;
//存储items索引值
private int[] pq;
//存储pq中索引的逆序,pq的值为索引，索引为值
private int[] qp;
//存储堆中数据
private int N;
//构造函数初始化参数
public IndexMaxPriorityQueue(int capacity) {
items = (T[]) new Comparable[capacity + 1];
pq = new int[capacity + 1];
qp = new int[capacity + 1];
this.N = 0;
// for (int i : qp) {
// qp[i] = -1;
// }
//默认队列不存储元素
for (int i = 0; i < qp.length; i++) {
qp[i] = -1;
}
}
//队列是否为空
public boolean isEmpty() {
return N == 0;
}
//队列大小
public int size() {
return N;
}
public boolean max(int i, int j) {
return items[pq[i]].compareTo(items[pq[j]]) > 0;
}
//交换元素顺序
public void exch(int i, int j) {
//交换pq中索引顺序
int temp = pq[i];
pq[i] = pq[j];
pq[j] = temp;
//更新qp中数据
qp[pq[i]] = i;
qp[pq[j]] = j;
}
//是否包含对应索引
public boolean contain(int i) {
return qp[i] != -1;
}
//最大索引
public int maxIndex() {
return pq[1];
}
//索引i处插入元素
public void insert(int i, T t) {
if (contain(i)) {
return;
}
//items处插入元素t
items[i] = t;
//个数自增
N++;
//pq增加索引映射
pq[N] = i;
//qp增加逆序
qp[i] = N;
//上浮调整堆顺序
swim(N);
}
//删除最大索引
public int delMaxIndex() {
//找到最大元素索引
int maxIndex = pq[1];
//交换元素
exch(1, N);
//删除元素
items[maxIndex] = null;
//删除逆索引
qp[pq[N]] = -1;
//删除索引
pq[N] = -1;
//元素减少
N--;
//下沉调整堆顺序
sink(1);
return maxIndex;
}
//删除索引i处元素
public void delete(int i) {
//找到索引i在pq中位置，pq调整顺序
int k = qp[i];
//交换k处元素位置
exch(k, N);
//删除元素
items[k] = null;
qp[pq[N]] = -1;
//删除pq中元素
pq[N] = -1;
//堆调整顺序
sink(k);
swim(k);
}
//修改索引i处的值为t
public void changeItems(int i, T t) {
items[i] = t;
int k = qp[i];
swim(k);
sink(k);
}
//通过上浮，调整堆顺序
public void swim(int k) {
while (k > 1) {
if (max(k, k / 2)) {
exch(k, k / 2);
}
k = k / 2;
}
}
//通过下沉，调整堆顺序
public void sink(int k) {
while (2 * k <= N) {
//找到子节点最大值
int max;
if (2 * k + 1 <= N) {
if (max(2 * k + 1, 2 * k)) {
max = 2 * k + 1;
} else {
max = 2 * k;
}
} else {
max = 2 * k;
}
if (max(k, max)) {
break;
}
exch(k, max);
k = max;
}
}
public static void main(String[] args) {
//创建索引最小优先队列对象
IndexMaxPriorityQueue<String> queue = new IndexMaxPriorityQueue<>(10);
//往队列中添加元素
queue.insert(0, "A");
queue.insert(1, "C");
queue.insert(2, "F");
//测试修改
queue.changeItems(2, "B");
//测试删除
while (!queue.isEmpty()) {
int index = queue.delMaxIndex();
System.out.print(index + " ");
}
}
}
203
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
