系列文章目录
集合及数据结构第十节(上)————优先级队列,堆的创建、插入、删除与用堆模拟实现优先级队列
优先级队列,堆的创建、插入、删除与用堆模拟实现优先级队列
- 优先级队列的概念
- 堆的概念
- 堆的存储方式
- 堆的创建
- 变量的作用域和生命周期
- 用堆模拟实现优先级队列
文章目录
- 系列文章目录
- 集合及数据结构第十节(上)————优先级队列,堆的创建、插入、删除与用堆模拟实现优先级队列
- 一、优先级队列
- 1.优先级队列的概念
- 二、优先级队列的模拟实现
- 1. 堆的概念
- 2. 堆的存储方式
- 3. 堆的创建
- 堆向下调整
- 建堆的时间复杂度
- 5.变量的作用域和生命周期( * * * )
- 堆的插入
- 堆的删除
- 6.用堆模拟实现优先级队列
- 常见习题:
一、优先级队列
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)/2for (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 + 1while (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)/2if (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 + 1while (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 + 1while (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)/2if (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]