概念
队列(PriorityQueue)是一种先进先出的数据结构,但是有些情况下,操作的数据可能带有优先级,一般出队列时,可能需要优先级高的元素先出队列。在这种情况下,数据结构提供了两个最基本的操作,一个返回最高优先级对象,一个是添加新的对象,这种数据结构就是优先级队列。
PriorityQueue是线程不安全的,而PriorityBlockingQueue是线程安全的。
注意:
1.使用前必须先导入所对应的包;
import java.util.PriorityQueue;
2.PriorityQueue中放置的元素必须能够比较大小,不能插入无法比较的对象,否则会抛出ClassCastException异常;
3.不能插入null对象,否则会抛出NullPointerException异常;
4.没有容量限制,可以插入任意多个元素,其内部可以自动扩容;
5.插入和删除元素的时间复杂度为O(logN);
6.PriorityQueue底层使用了堆数据结构。
常用接口
- 构造方法
public static void testPriorityQueue1(){
//1.构造一个空的优先级队列 注意:空的优先级队列,底层已经有了11个默认空间
PriorityQueue<Integer> p1 = new PriorityQueue<>();
//2.按照指定容量来进行构造
//如果大概知道优先级队列要放多少元素,最好使用该种方式进行构造
//不要使用空的进行构造,影响程序效率
PriorityQueue<Integer> p2 = new PriorityQueue<>(20);
//3.可以用一个集合来直接构造优先级队列,将来就会将集合中的元素放到优先级队列中
List<Integer> l = new ArrayList<>();
l.add(0);
l.add(1);
l.add(2);
l.add(3);
l.add(4);
//使用list构造优先级队列时,并不是直接把元素拷贝进来,而是按照一定规则进行排列
PriorityQueue<Integer> p3 = new PriorityQueue<>(l);
System.out.println(p3.size());
}
- 内部方法
模拟实现
import java.util.Arrays;
interface Comp{
public int compare(int left, int right);
}
class Less implements Comp{
//0:left == right
//>0:left > right
//<0:left < right
public int compare(int left, int right){
return left - right;
}
}
class Greater implements Comp{
public int compare(int left, int right){
return right - left;
}
}
public class MyPriorityQueue {
private int[] array;
private int size;
Comp compare = null;
public MyPriorityQueue(Comp comp){
//默认的构造方法,底层容量为11
array = new int[11];
size = 0;
compare = comp;
}
public MyPriorityQueue(int initCapacity, Comp comp){
if(initCapacity < 1){
//标准库:抛出一个非法参数的异常
initCapacity = 11;
}
array = new int[initCapacity];
size = 0;
compare = comp;
}
//标准库中没有该接口-->标准库中采用集合来构造优先级队列
public MyPriorityQueue(int[] arr, Comp comp){
array = new int[arr.length];
for(int i = 0;i < arr.length;i++){
array[i] = arr[i];
}
size = array.length;
compare = comp;
//将array中的元素进行调整,让其满足小堆的性质
int node = (arr.length - 2) >> 1;
for(;node >= 0;node--){
shiftDown(node);
}
}
int peek(){
//标准库中,如果优先级队列是空,无法获取堆顶元素,返回null
return array[0];
}
boolean offer(int x){
//检测是否需要扩容
if(size >= array.length){
grow();
}
//将x尾插到数组中
array[size++] = x;
shiftUp(size - 1);
return true;
}
int poll(){
int ret = array[0];
swap(0,size - 1);
size--;
shiftDown(0);
return ret;
}
boolean isEmpty(){
return 0 == size;
}
void clear(){
size = 0;
}
private void shiftDown(int parent) {
int size = array.length;
//使用child标记parent的左孩子
//默认标记左孩子,因为parent可能只有左孩子没有右孩子
int child = parent * 2 + 1;
while (child < array.length) {
//child标记较小的孩子
//利用左右孩子进行比较时,必须保证右孩子存在
//if (child + 1 < size && array[child + 1] > array[child]) {
if(child + 1 < size && compare.compare(array[child + 1], array[child]) > 0){
child += 1;
}
//检测双亲是否比较小的孩子大
//if (array[child] > array[parent]) {
if(compare.compare(array[child],array[parent]) > 0){
//说明双亲不满足小堆的性质,将child与parent的元素交换
swap(child, parent);
//parent较大的元素向下移动,可能会导致子树不满足堆的性质
parent = child;
child = parent * 2 + 1;
} else {
//双亲已经满足堆的性质
return;
}
}
}
private void shiftUp(int child){
int parent = (child - 1) >> 1;
while(child != 0){
//if(array[child] < array[parent]){
if(compare.compare(array[child], array[parent]) < 0){
swap(child, parent);
child = parent;
parent = (child - 1) >> 1;
}
else{
return;
}
}
}
private void swap(int child, int parent){
int temp = array[child];
array[child] = array[parent];
array[parent] = temp;
}
private void grow(){
int oldCapacity = array.length;
int newCapacity = oldCapacity + ((oldCapacity < 64) ? (oldCapacity + 2) : oldCapacity >> 1);
array = Arrays.copyOf(array, newCapacity);
}
}