一.最大优先队列
1.概念
普通的队列是一种先进先出(尾插头取)的数据结构,元素在队列尾追加,而从队列头删除。
在某些情况下,我们可能需要找出队列中的最大值或者最小值,例如使用一个队列保存计算机的任务,一般情况下计算机的任务都是有优先级的,我们需要在这些计算机的任务中找出优先级最高的任务先执行,执行完毕后就需要把这个任务从队列中移除。
普通的队列要完成这样的功能,需要每次遍历队列中的所有元素,比较并找出最大值,效率不是很高,这个时候,我们就可以使用一种特殊的队列来完成这种需求,优先队列,需要基于堆的思想来实现。
由堆的特性,其最大值在根节点处,每次将根节点取出,就相当于是获取了优先级最大的数。
最大优先队列的实现代码与堆的实现代码基本一致,底层同样是使用了数组。重点是理解swim sink delMax方法的逻辑即可。
堆的Java实现
优先队列按照其作用不同,可以分为以下两种:
最大优先队列:可以获取并删除队列中最大的值
最小优先队列:可以获取并删除队列中最小的值
2.实现
public class MaxPriorityQueue<T extends Comparable> { //最大优先队列
private T[] items; //优先队列基于堆的结构来实现,所以也用数组
private int N;
public MaxPriorityQueue(int capacity) {
this.N = 0;
this.items = (T[]) new Comparable[capacity + 1]; //会废弃掉0索引
}
private void swap(int i, int j) {
T temp = items[i];
items[i] = items[j];
items[j] = temp;
}
private boolean more(int i, int j) {
return (items[i].compareTo(items[j]) > 0);
}
public void insert(T t) {
items[++N] = t; //使用++N能废弃掉0索引;新加入的元素索引为N
swim(N); //对索引N的元素使用上浮方法使其有序
}
public T delMax() {
T max = items[1]; //仅记录要删除的最大元素
swap(1, N);// 将最大元素和索引N处元素交换
items[N] = null; //删除最大元素
N--;
sink(1); // 通过sink方法让堆变得有序
return max;
}
private void swim(int k) { //上浮,和父节点比较!
while (k > 1) { //如果k已经到了根节点,则不再需要循环
if (more(k, k / 2)) { //如果当前k处结点大于其父结点,则交换
swap(k, k / 2);
k = k / 2;
} else { //如果当前k处结点小于其父结点,则跳出循环
break;
}
}
}
private void sink(int k) { //下沉,和子节点的较大值比较!
int max;
while (2 * k <= N) { //k存在左子节点 ,若不存在左子结点2k,也不会存在右子节点2k+1 了!
if (2 * k + 1 <= N) { //且存在右子节点
//找出左右子节点的最大
if (more(2 * k, 2 * k + 1)) { //如果左大于右
max = 2 * k;
} else {
max = 2 * k + 1;
}
} else { //只有左子结点
max = 2 * k;
}
//比较当前k结点和max
if (!more(k, max)) {
swap(k, max);//k小于子节点中最大,则交换
k = max;
} else {
break;
}
}
}
public int size() {
return N;
}
public boolean isEmpty() {
return size() == 0;
}
public static void main(String[] args) {
MaxPriorityQueue<String> p = new MaxPriorityQueue<>(20);
p.insert("A");
p.insert("B");
p.insert("C");
p.insert("D");
p.insert("E");
p.insert("F");
p.insert("G");
while (!p.isEmpty()) {
String s = p.delMax();
System.out.print("删除当前最大:"+s + "\n");
}
}
}
测试部分中,每一轮循环输出当前优先级队列中的最大值,输出结果:
删除当前最大:G
删除当前最大:F
删除当前最大:E
删除当前最大:D
删除当前最大:C
删除当前最大:B
删除当前最大:A
二.最小优先队列
最小优先队列的实现逻辑和最大优先队列的基本一样。只是将more换成了less
前面学习堆的时候,堆中存放数据元素的数组要满足都满足如下特性:
1.最大的元素放在数组的索引1处。
2.每个结点的数据总是大于等于它的两个子结点的数据。
最大优先队列的swim和sink:
上浮:将当前结点k和父节点作比较,若k结点大于父结点,则交换k和父节点
下沉:求出当前结点的两个子节点的最大值max,若当前结点k小于max,则交换max和k
(数据大的往前放)
其实我们之前实现的堆可以把它叫做最大堆,我们可以用相反的思想实现最小堆,让堆中存放数据元素的数组满足
如下特性:
1.最小的元素放在数组的索引1处。
2.每个结点的数据总是小于等于它的两个子结点的数据。
最小优先队列的swim和sink
上浮:将当前结点k和父节点作比较,若k结点小于父结点,则交换k和父节点
下沉:求出当前结点的两个子节点的最小值min,若当前结点k大于min,则交换min和k
(数据小的往前放)
实现:
public class minPriorityQueue<T extends Comparable> {
private T[] items; //优先队列基于堆的结构来实现,所以也用数组
private int N;
public minPriorityQueue(int capacity) {
this.N = 0;
this.items = (T[]) new Comparable[capacity + 1]; //会废弃掉0索引
}
private void swap(int i, int j) {
T temp = items[i];
items[i] = items[j];
items[j] = temp;
}
private boolean less(int i, int j) { //比较
return (items[i].compareTo(items[j]) <0);
}
public void insert(T t) {
items[++N] = t; //使用++N能废弃掉0索引;新加入的元素索引为N
swim(N); //对索引N的元素使用上浮方法使其有序
}
public T delMin() {
T min = items[1]; //仅记录要删除的最大元素
swap(1, N);// 将最小元素和索引N处元素交换
items[N] = null; //删除最小元素
N--;
sink(1); // 通过sink方法让堆变得有序
return min;
}
private void swim(int k) {
while (k > 1) { //如果k已经到了根节点,则不再需要循环
if (less(k, k / 2)) { //如果当前结点k小于父结点,则交换
swap(k, k / 2);
k = k / 2;
} else {
break;
}
}
}
private void sink(int k) {
int min;
while (2 * k <= N) { //k存在左子节点
if (2 * k + 1 <= N) { //且存在右子节点
//找出左右子节点的最小
if (less(2 * k, 2 * k + 1)) { //如果左小于右
min = 2 * k;
} else {
min = 2 * k + 1;
}
} else { //只有左子结点
min = 2 * k;
}
//比较当前k结点和max
if (!less(k, min)) {
swap(k, min);//当前结点k大于子节点中最小,则交换
k = min;
} else {
break;
}
}
}
public int size() {
return N;
}
public boolean isEmpty() {
return size() == 0;
}
public static void main(String[] args) {
minPriorityQueue<String> p = new minPriorityQueue<String>(20);
p.insert("A");
p.insert("B");
p.insert("C");
p.insert("D");
p.insert("E");
p.insert("F");
p.insert("G");
while (!p.isEmpty()) {
String s = p.delMin();
System.out.print(s + " ");
}
}
}
测试结果:(小的优先取出) A B C D E F G