一、优先级队列
1.1概念
有两个最基本操作,一是返回最高优先级对象,二是添加新对象,这种数据结构就叫做优先级队列。
二、优先级队列模拟实现
通过堆这种数据结构可以实现优先级队列,堆其实就是对完全二叉树进行了一些调整。
2.1堆的概念
堆分为小根堆和大根堆,如果一颗完全二叉树,其左右节点均大于根结点,就叫做小根堆;
如果左右节点均小于根结点,就叫做大根堆。
2.2堆的性质
(1)堆总是一颗完全二叉树。
(2)堆的某个节点总是大于或小于父亲结点的值。
2.3堆的存储方式
由于堆是一颗完全二叉树,因此我们可以用层序遍历的方式来实现高效存储。
2.4堆的创建
2.4.1通过向下调整创建堆
调整过程(以大根堆为列):
(1)让parent标记需要调整的节点,child标记parent的左孩子;
(2)如果parent的左孩子存在,即:child < size, 进行以下操作,直到parent的左孩子不存在
[1] parent右孩子是否存在,存在找到左右孩子中最大的孩子,让child进行标记
[2]将parent与较小的孩子child比较,如果parent大于较小的孩子child,调整结束,否则,交换parent与较小的孩子child,交换完成之后,parent中大的元素向下移动,可能导致子树不满足对的性质,因此需要继续向下调整,即parent = child;child = parent*2+1; 然后继续(2);
public class MyPriorityQueue {
public int[] elem;
public int usedSize;
public MyPriorityQueue(){
this.elem=new int[10];
}
//传一个数组,对堆初始化
public void initElem(int[] array){
for(int i=0;i<array.length;i++){
this.elem[i]=array[i];
//每插入一个数据,usedSize++
this.usedSize++;
}
}
public void createPriorityQueue( ){
//计算出最后一颗子树的父亲节点并用parent标记,然后
//通过parent--对每棵子树进行调整,直到parent<0
for (int parent=(this.usedSize-1-1)/2;parent>=0;
parent--) {
//向下调整
shiftDown(parent,this.usedSize);
}
}
//向下调整
private void shiftDown(int parent, int usedSize) {
int child=2*parent+1;
while(child<usedSize){
//找到左右孩子最大值
if(child+1<usedSize && elem[child]<elem[child+1]){
child++;
}
if(elem[child]>elem[parent]){
int tmp=elem[child];
elem[child]=elem[parent];
elem[parent]=tmp;
parent=child;
child=2*parent+1;
}else{
//说明当前树已经调整完了
break;
}
}
}
2.4.2建堆的时间复杂度
建堆的时间复杂度为O(N)
2.5堆的插入与删除
2.5.1堆的插入
public void offer(int val){
if(isFull()){
elem= Arrays.copyOf(elem,
2*elem.length);
}
elem[usedSize]=val;
int child=usedSize;
int parent=(child-1)/2;
usedSize++;
while(parent>=0){
if(elem[parent]<elem[child]){
int tmp=elem[parent];
elem[parent]=elem[child];
elem[child]=tmp;
child=parent;
parent=(child-1)/2;
}else {
break;
}
}
}
图示如下(图中是以小根堆为例)
2.5.2堆的删除
public int poll(){
//先判断队列是否为空
if(isEmpty()){
return -1;
}
int val=elem[0];
swap(Collections.singletonList(elem),
0,usedSize-1);
shiftDown(0,usedSize-1);
usedSize--;
return val;
}
public boolean isEmpty(){
return usedSize==0;
}
图示:
2.6常用接口
2.6.1PriorityQueue的特性
2.6.2PriorityQueue常用接口介绍
2.6.2.1优先级队列的构造
static void TestPriorityQueue() {
// 创建一个空的优先级队列,底层默认容量是11
PriorityQueue<Integer> q1 = new PriorityQueue<>();
// 创建一个空的优先级队列,底层的容量为initialCapacity
PriorityQueue<Integer> q2 = new PriorityQueue<>(100);
ArrayList<Integer> list = new ArrayList<>();
list.add(4);
list.add(3);
list.add(2);
list.add(1);
// 用ArrayList对象来构造一个优先级队列的对象
// q3中已经包含了三个元素
PriorityQueue<Integer> q3 = new PriorityQueue<>(list);
System.out.println(q3.size());
System.out.println(q3.peek());
}
注意:默认情况下,PriorityQueue队列是小堆,如果需要大堆需要用户提供比较器
// 用户自己定义的比较器:直接实现Comparator接口,然后重写该接口中的compare方法即可
class IntCmp implements Comparator<Integer>{
@Override
public int compare(Integer o1, Integer o2) {
return o2-o1;
}
}
public class TestPriorityQueue {
public static void main(String[] args) {
PriorityQueue<Integer> p = new PriorityQueue<>(new IntCmp());
p.offer(4);
p.offer(3);
p.offer(2);
p.offer(1);
p.offer(5);
System.out.println(p.peek());
}
}
2.6.2.2插入/删除/获取优先级最高的元素
![](https://i-blog.csdnimg.cn/direct/b8ec2f477aaf498699eef72354a1344d.png)
static void TestPriorityQueue2(){
int[] arr = {4,1,9,2,8,0,7,3,6,5};
// 一般在创建优先级队列对象时,如果知道元素个数,建议就直接将底层容量给好
// 否则在插入时需要不多的扩容
// 扩容机制:开辟更大的空间,拷贝元素,这样效率会比较低
PriorityQueue<Integer> q = new PriorityQueue<>(arr.length);
for (int e: arr) {
q.offer(e);
}
System.out.println(q.size()); // 打印优先级队列中有效元素个数
System.out.println(q.peek()); // 获取优先级最高的元素
// 从优先级队列中删除两个元素之和,再次获取优先级最高的元素
q.poll();
q.poll();
System.out.println(q.size()); // 打印优先级队列中有效元素个数
System.out.println(q.peek()); // 获取优先级最高的元素
q.offer(0);
System.out.println(q.peek()); // 获取优先级最高的元素
// 将优先级队列中的有效元素删除掉,检测其是否为空
q.clear();
if(q.isEmpty()){
System.out.println("优先级队列已经为空!!!");
}
else{
System.out.println("优先级队列不为空");
}
}
注意:以下是JDK 1.8中,PriorityQueue的扩容方式:
private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;
private void grow(int minCapacity) {
int oldCapacity = queue.length;
// Double size if small; else grow by 50%
int newCapacity = oldCapacity + ((oldCapacity < 64) ?
(oldCapacity + 2) :
(oldCapacity >> 1));
// overflow-conscious code
if (newCapacity - MAX_ARRAY_SIZE > 0)
newCapacity = hugeCapacity(minCapacity);
queue = Arrays.copyOf(queue, newCapacity);
}
private static int hugeCapacity(int minCapacity) {
if (minCapacity < 0) // overflow
throw new OutOfMemoryError();
return (minCapacity > MAX_ARRAY_SIZE) ?
Integer.MAX_VALUE :
MAX_ARRAY_SIZE;
}
2.7堆的应用
2.7.1堆排序
![](https://i-blog.csdnimg.cn/direct/bd0be82f744e43cd9ec0c1f81085f0f5.png)
代码示例:
public void headSort(){
int end=usedSize-1;
while(end>0){
swap(Collections.singletonList(elem),0,end);
shiftDown(0,end);
end--;
}
}
2.7.2Top-K问题