系列文章目录
集合及数据结构第十节（上）————优先级队列，堆的创建、插入、删除与用堆模拟实现优先级队列
优先级队列，堆的创建、插入、删除与用堆模拟实现优先级队列
- 优先级队列的概念
- 堆的概念
- 堆的存储方式
- 堆的创建
- 变量的作用域和生命周期
- 用堆模拟实现优先级队列
文章目录
一、优先级队列
1.优先级队列的概念
前面介绍过队列，队列是一种先进先出(FIFO)的数据结构，但有些情况下，操作的数据可能带有优先级，一般出队列时，可能需要优先级高的元素先出队列，该中场景下，使用队列显然不合适，比如：在手机上玩游戏的时候，如果有来电，那么系统应该优先处理打进来的电话；初中那会班主任排座位时可能会让成绩好的同学先挑座位。在这种情况下，数据结构应该提供两个最基本的操作，一个是返回最高优先级对象，一个是添加新的对象。这种数据结构就是优先级队列(Priority Queue)
二、优先级队列的模拟实现
JDK1.8中的PriorityQueue底层使用了堆这种数据结构，而堆实际就是在完全二叉树的基础上进行了一些调整。
1. 堆的概念
如果有一个关键码的集合K = {k0，k1， k2，…，kn-1}，把它的所有元素按完全二叉树的顺序存储方式存储 在一个一维数组中，并满足：Ki <= K2i+1 且 Ki<= K2i+2 (Ki >= K2i+1 且 Ki >= K2i+2) i = 0，1，2…，则称为 小堆(或大堆)。将根节点最大的堆叫做最大堆或大根堆，根节点最小的堆叫做最小堆或小根堆
数组可以存储一个非完全二叉树，但是会出现浪费空间的情况。
堆的性质:
- 堆中某个节点的值总是不大于或不小于其父节点的值；
- 堆总是一棵完全二叉树
2. 堆的存储方式
从堆的概念可知，堆是一棵完全二叉树，因此可以层序的规则采用顺序的方式来高效存储
注意：对于非完全二叉树，则不适合使用顺序方式进行存储，因为为了能够还原二叉树，空间中必须要存储空节点，就会导致空间利用率比较低。
将元素存储到数组中后，可以根据二叉树章节的性质5对树进行还原。假设i为节点在数组中的下标，则有：
- 如果i为0，则i表示的节点为根节点，否则i节点的双亲节点为 (i - 1)/2
- 如果2 * i + 1 小于节点个数，则节点i的左孩子下标为2 * i + 1，否则没有左孩子
- 如果2 * i + 2 小于节点个数，则节点i的右孩子下标为2 * i + 2，否则没有右孩子
3. 堆的创建
堆向下调整
对于集合{ 27,15,19,18,28,34,65,49,25,37 }中的数据，如果将其创建成堆呢？、
仔细观察上图后发现：根节点的左右子树已经完全满足堆的性质，因此只需将根节点向下调整好即可
大根堆：
向下调整过程思路：
- 从最后一棵子树（下标为 9 的节点）开始调整
- 找到左右孩子的最大值并与根节点进行比较，如果比根节点大，那么就交换。
- 知道当前子树的根节点下标，就能知道下一棵需要调整的子树，为当前节点下标 - 1
- 一直调整到 0 下标这颗树时停止调整
要完成代码存在的问题：
- 每颗子树在调整的时候，什么时候能结束这颗子树的调整。
- 定义树的节点个数为len(数组长度)，当当前下标为 i 的子树的左孩子下标 2 * i + 1 > len或者右孩子下标2 * i + 2 > len时，该子树调整完毕了
- 最后一棵子树的根节点下标怎么确定。
向下调整过程(以大根堆为例)：
- 让parent标记需要调整的节点，child标记parent的左孩子(注意：parent如果有孩子一定先是有左孩子)
- 如果parent的左孩子存在，即:child < usedSize， 进行以下操作，直到parent的左孩子不存在
parent右孩子是否存在，存在找到左右孩子中最大的孩子，让child进行标
将parent与较大的孩子child比较，如果：
parent小于较大的孩子child，调整结束
否则：交换parent与较大的孩子child，交换完成之后，parent中小的元素向下移动，可能导致子树不满足对的性质，因此需要继续向下调整，即parent
= child；child = parent*2+1; 然后继续步骤2的操作。
完整代码：
public class TestHeap {
private int[] elem;//用来存完全二叉树的数组
public int usedSize;//用来记录当前堆中有效的数据个数
public TestHeap(){//构造方法
this.elem = new int[10];//初始化数组大小为10
}
public void initElem(int[] array){//初始化elem数组
for (int i = 0; i < array.length; i++) {
elem[i] = array[i];
usedSize++;//拷贝一个有效数据加1
}
}
public void createHeap(){//创建大根堆
//usedSize - 1 -->len //usedSize - 1 - 1 -->拿到最后一个孩子节点(9)下标 //(usedSize - 1 - 1) / 2 -->拿到该孩子节点的父亲节点
//如果i为0，则i表示的节点为根节点，否则i节点的双亲节点为 (i - 1)/2
for (int parent = (usedSize - 1 - 1) / 2;parent >= 0;parent--){//确定每棵子树parent的下标
siftDown(parent,usedSize);//每棵子树向下调整,传参为每颗子树的根和结束的位置
}
}
public void siftDown(int parent,int len){//每棵子树向下调整
int child = 2 * parent + 1;//parent节点的左孩子下标为2 * i + 1
while (child < len){//当至少有左孩子时
//在进行比较的时候要保证child + 1 < len,否则就会越界比较
if (child + 1 < len && elem[child] < elem[child + 1]){//左孩子和右孩子进行比较，如果右孩子的值大，那么就记录一下它的下标
child = child + 1;
}
//走完上述if语句，则child下标一定保存的是左右两个孩元素最大值的下标
if (elem[child] > elem[parent]){//child下标的元素大于parent下标的元素，进行交换
int temp = elem[child];
elem[child] = elem[parent];
elem[parent] = temp;
parent = child;//parent指向child的位置
child = 2 * parent + 1;//再接着对child的右孩子进行相同操作，parent节点的左孩子下标为2 * i + 1
}else{
break;//不需要比较了，直接break退出循环
}
}
}
}
建堆的时间复杂度
因为堆是完全二叉树，而满二叉树也是完全二叉树，此处为了简化使用满二叉树来证明(时间复杂度本来看的就是近似值，多几个节点不影响最终结果：
因此：建堆的时间复杂度为O(N)。
5.变量的作用域和生命周期（ * * * ）
堆的插入
堆的插入总共需要两个步骤：
- 先将元素放入到底层空间中(注意：空间不够时需要扩容)
- 将最后新插入的节点向上调整，直到满足堆的性质
向上调整： - 将新增节点child于其父亲节点parent进行比较，如果大于父亲节点parent就与其交换
- 交换结束后调整child和parent的位置
代码实现：
public void push(int val){//堆的插入
//满了时
if (isFull()){
elem = Arrays.copyOf(elem,elem.length * 2);//二倍扩容
}
elem[usedSize] = val;
//向上调整
siftUp(usedSize);
usedSize++;//插入后usedSize加一
}
public void swap(int child,int parent){
int temp = elem[child];
elem[child] = elem[parent];
elem[parent] = temp;
}
public boolean isFull(){
return usedSize == elem.length;//当usedSize和数组的长度相等时，说明满了
}
public void siftUp(int child){//向上调整
while (child > 0){
int parent = (child - 1) / 2;//如果i为0，则i表示的节点为根节点，否则i节点的双亲节点为 (i - 1)/2
if (elem[usedSize] > elem[parent]){//如果大于父亲节点parent就与父亲节点parent交换
swap(child,parent);//交换
child = parent;//当前child指向parent的位置
parent = (child - 1) / 2;
}else {//如果小于父亲节点parent，说明该子树已经是大根堆，break跳出循环
break;
}
}
}
}
补充：
向上调整也可以建堆但是时间复杂度会比较高
堆的删除
注意：堆的删除一定删除的是堆顶元素。具体如下：
- 将堆顶元素对堆中最后一个元素交换
- 将堆中有效数据个数减少一个
- 对堆顶元素进行向下调整
public class heapEmptyWrong extends RuntimeException{//堆为空的异常
public heapEmptyWrong(String message) {
super(message);
}
}
public void swap(int child,int parent){//交换
int temp = elem[child];
elem[child] = elem[parent];
elem[parent] = temp;
}
public void siftDown(int parent,int len){//每棵子树向下调整
int child = 2 * parent + 1;//parent节点的左孩子下标为2 * i + 1
while (child < len){//当至少有左孩子时
//在进行比较的时候要保证child + 1 < len,否则就会越界比较
if (child + 1 < len && elem[child] < elem[child + 1]){//左孩子和右孩子进行比较，如果右孩子的值大，那么就记录一下它的下标
child = child + 1;
}
//走完上述if语句，则child下标一定保存的是左右两个孩元素最大值的下标
if (elem[child] > elem[parent]){//child下标的元素大于parent下标的元素，进行交换
int temp = elem[child];
elem[child] = elem[parent];
elem[parent] = temp;
parent = child;//parent指向child的位置
child = 2 * parent + 1;//再接着对child的右孩子进行相同操作，parent节点的左孩子下标为2 * i + 1
}else{
break;//不需要比较了，直接break退出循环
}
}
}
public int pop(){//删除堆的元素
//判断堆是否为空
if (isEmpty()){//抛出异常
throw new heapEmptyWrong("当前堆为空，不能进行删除操作");
}
int oldVal = elem[0];//记录对顶元素
swap(0,usedSize - 1);//堆顶元素对堆中最后一个元素交换
usedSize--;
siftDown(0,usedSize);//0-usedSize的元素进行向下调整
return oldVal;
}
6.用堆模拟实现优先级队列
public class heapEmptyWrong extends RuntimeException{//堆为空的异常
public heapEmptyWrong(String message) {
super(message);
}
}
public void swap(int child,int parent){//交换
int temp = elem[child];
elem[child] = elem[parent];
elem[parent] = temp;
}
public void siftDown(int parent,int len){//每棵子树向下调整
int child = 2 * parent + 1;//parent节点的左孩子下标为2 * i + 1
while (child < len){//当至少有左孩子时
//在进行比较的时候要保证child + 1 < len,否则就会越界比较
if (child + 1 < len && elem[child] < elem[child + 1]){//左孩子和右孩子进行比较，如果右孩子的值大，那么就记录一下它的下标
child = child + 1;
}
//走完上述if语句，则child下标一定保存的是左右两个孩元素最大值的下标
if (elem[child] > elem[parent]){//child下标的元素大于parent下标的元素，进行交换
int temp = elem[child];
elem[child] = elem[parent];
elem[parent] = temp;
parent = child;//parent指向child的位置
child = 2 * parent + 1;//再接着对child的右孩子进行相同操作，parent节点的左孩子下标为2 * i + 1
}else{
break;//不需要比较了，直接break退出循环
}
}
}
public void siftUp(int child){//向上调整
while (child > 0){
int parent = (child - 1) / 2;//如果i为0，则i表示的节点为根节点，否则i节点的双亲节点为 (i - 1)/2
if (elem[usedSize] > elem[parent]){//如果大于父亲节点parent就与父亲节点parent交换
swap(child,parent);//交换
child = parent;//当前child指向parent的位置
parent = (child - 1) / 2;
}else {//如果小于父亲节点parent，说明该子树已经是大根堆，break跳出循环
break;
}
}
}
public class MyPriorityQueue {
private int[] array = new int[100];
private int size = 0;
public void push(int val){//堆的插入
//满了时
if (isFull()){
elem = Arrays.copyOf(elem,elem.length * 2);//二倍扩容
}
elem[usedSize] = val;
//向上调整
siftUp(usedSize);
usedSize++;//插入后usedSize加一
}
public int pop(){//删除堆的元素
//判断堆是否为空
if (isEmpty()){//抛出异常
throw new heapEmptyWrong("当前堆为空，不能进行删除操作");
}
int oldVal = elem[0];//记录对顶元素
swap(0,usedSize - 1);//堆顶元素对堆中最后一个元素交换
usedSize--;
siftDown(0,usedSize);//0-usedSize的元素进行向下调整
return oldVal;
}
public int peek() {
return elem[0];
}
}
常见习题：
1.下列关键字序列为堆的是:( A )
A: 100,60,70,50,32,65
B: 60,70,65,50,32,100
C: 65,100,70,32,50,60
D: 70,65,100,32,50,60
E: 32,50,100,70,65,60
F: 50,100,70,65,60,32
2.已知小根堆为8,15,10,21,34,16,12，删除关键字8之后需重建堆，在此过程中，关键字之间的比较次数是( C )
A: 1
B: 2
C: 3
D: 4
4.最小堆[0,3,2,5,7,4,6,8],在删除堆顶元素0之后，其结果是( C )
A: [3，2，5，7，4，6，8]
B: [2，3，5，7，4，6，8]
C: [2，3，4，5，7，8，6]
D: [2，3，4，5，6，7，8]
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
