0 优先队列
- 普通队列先进先出,队尾加,队头删;
- 某些情况下,我们需要找出队列中的最大值或最小值。比如使用一个队列保存计算机的任务,任务需要有优先级,我们需要找出优先级最高的任务先执行,执行完毕后将任务从队列删除。
- 普通队列完成任务,需要遍历队列所有元素,比较并找出最大值,效率低下;
- 这时可以使用一种特殊的队列来完成需求,即优先队列。
- 按照功能需求分两种:1 最大优先队列:获取并删除队列中最大的值;2 最小优先队列:获取并删除队列中最小的值。
1 最大优先队列
由于堆可以很方便地删除最大值,因此基于堆实现最大优先队列。
Java实现:
public class MaxPriorityQueue<T extends Comparable<T>> {
//存储堆中的元素
private T[] items;
//记录堆中元素的个数
private int N;
public MaxPriorityQueue(int capacity) {
this.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 T delMax() {
T max = items[1];
exch(1,N);
items[N] = null;
N--;
sink(1);
return max;
}
//使用上浮算法,使索引k处的元素能在堆中处于一个正确的位置
private void swim(int k) {
while(k>1){
if (less(k/2,k)){
exch(k/2,k);
} else {
break;
}
k = k/2;
}
}
//使用下沉算法,使索引k处的元素能在堆中处于一个正确的位置
private void sink(int k) {
while(2*k<=N){
int max;
if (2*k+1<=N){
if (less(2*k,2*k+1)){
max = 2*k+1;
}else{
max = 2*k;
}
}else {
max = 2*k;
}
if (!less(k,max)){
break;
}
exch(k,max);
k = max;
}
}
//判断堆中索引i处的元素是否小于索引j处的元素
private boolean less(int i, int j) {
return items[i].compareTo(items[j])<0;
}
//交换堆中i索引和j索引处的值
private void exch(int i, int j) {
T tmp = items[i];
items[i] = items[j];
items[j] = tmp;
}
}
public class Test {
public static void main(String[] args) {
String[] arr = {"S","O","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 + ",");
}
}
}
10
X,T,S,P,O,M,L,E,E,A,
2 最小优先队列
最大优先队列基于堆的思想实现,堆中存放数据的数组满足如下两个特性:
- 最大元素放在数组的索引1处;
- 每个结点的数据总是大于等于它的两个子结点的数据。
为了实现最小优先队列,我们可以用相反的思想实现最小堆,使堆中存放数据的数据满足如下两个特性:
- 最小的元素放在数组的索引1处;
- 每个结点的数据总是小于等于它的两个子结点的数据。
Java代码实现:
public class MinPriorityQueue<T extends Comparable<T>> {
//存储堆中的元素
private T[] items;
//记录堆中元素的个数
private int N;
public MinPriorityQueue(int capacity) {
this.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 T delMin() {
T min = items[1];
exch(1,N);
items[N] = null;
N--;
sink(1);
return min;
}
//使用上浮算法,使索引k处的元素能在堆中处于一个正确的位置
private void swim(int k) {
//通过循环比较当前结点和其父结点的大小
while(k>1){
if (less(k,k/2)){
exch(k,k/2);
} else {
break;
}
k = k/2;
}
}
//使用下沉算法,使索引k处的元素能在堆中处于一个正确的位置
private void sink(int k) {
//通过循环比较当前结点和其子结点中的较小值
while(2*k<=N){
//1.找到子结点中的较小值
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;
}
//2.判断当前结点和较小值的大小
if (!less(min,k)){
break;
}
exch(k,min);
k = min;
}
}
//判断堆中索引i处的元素是否小于索引j处的元素
private boolean less(int i, int j) {
return items[i].compareTo(items[j])<0;
}
//交换堆中i索引和j索引处的值
private void exch(int i, int j) {
T tmp = items[i];
items[i] = items[j];
items[j] = tmp;
}
}
public class Test {
public static void main(String[] args) {
String[] arr = {"S","O","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 + ",");
}
}
}
10
A,E,E,L,M,O,P,S,T,X,