文章目录
目录
[一 . 堆](#一 . 堆)
[二 . 堆的创建(以大根堆为例)](#二 . 堆的创建(以大根堆为例))
[三 . 优先级队列](#三 . 优先级队列)
前言
大家好,今天给大家讲解一下堆这个数据结构和它的实现 - 优先级队列
一 . 堆
堆(Heap)是一种基于完全二叉树的数据结构,具有以下特点:
-
完全二叉树:堆是一种完全二叉树,即除了最后一层外,其他层的节点都是满的,并且最后一层的节点都靠左排列。
-
堆序性:堆中的每个节点都满足堆序性质,即对于最大堆(Max Heap),父节点的值大于或等于其子节点的值;对于最小堆(Min Heap),父节点的值小于或等于其子节点的值。
堆通常用数组来实现,其中数组的索引表示节点在堆中的位置。对于一个节点在索引i的堆,其左子节点在索引2i,右子节点在索引2i+1,父节点在索引i/2。
堆常常被用来实现优先级队列,因为它能够快速找到最大或最小的元素,并且在插入和删除操作时保持堆序性质。
常见的堆有两种类型:
-
最大堆(大根堆):父节点的值大于或等于其子节点的值。最大堆的根节点是堆中的最大元素。
-
最小堆(小根堆):父节点的值小于或等于其子节点的值。最小堆的根节点是堆中的最小元素。
堆的常见操作包括:
-
插入(Insertion):将一个元素插入到堆中,需要保持堆序性质。
-
删除根节点(Delete Root):删除堆中的根节点,需要调整堆以保持堆序性质。
-
查找最大/最小元素(Find Max/Min):在最大堆中查找最大元素,在最小堆中查找最小元素,时间复杂度为O(1)。
-
堆排序(Heap Sort):利用堆的性质进行排序,时间复杂度为O(nlogn)。
二 . 堆的创建(以大根堆为例)
初始化工作
public class BigHeap { int[] elem; // 用来记录堆中的元素 int size; public BigHeap(int capacity) { elem = new int[capacity]; } //再初始化的时候默认给一个数组 public void initHeap(int[] arr) { for (int i = 0; i < arr.length; i++) { elem[i] = arr[i]; size++; } } public boolean isFull() { return elem.length == size; } public void swap(int i,int j){ int temp = elem[i]; elem[i] = elem[j]; elem[j] = temp; }
}
堆的向下调整(重难点)
对于集合{ 27,15,19,18,28,34,65,49,25,37 }中的数据,如果将其创建成大根堆呢?
父节点的值大于或等于其子节点的值。最大堆的根节点是堆中的最大元素。
根据层序遍历构建出的二叉树显然并不符合我们的要求,这个是时候我们就需要进行向下调整
在最大堆中,向下调整的过程是将当前节点与其子节点中较大的节点进行比较,如果当前节点小于其中较大的子节点,就将它们交换位置。然后,继续向下比较和交换,直到当前节点不再小于其子节点或者已经到达叶子节点。
思考一下,这个时候我们应该从哪个节点进行调整?
我们通常是从最后一个非叶子节点开始向下调整,直到根节点或者到达叶子节点为止。从最后一个非叶子节点开始向下调整的原因是,只有非叶子节点才有子节点,而叶子节点没有子节点,所以没有必要对叶子节点进行向下调整操作。
最后一个非叶子节点的索引可以通过公式计算得到:n/2-1,其中n是堆中元素的数量。
步骤
-
让parent标记需要调整的节点,child标记parent的左孩子(注意:parent如果有孩子一定先是有左孩子,因为是完全二叉树)
-
如果parent的左孩子存在,即:child < len, 进行以下操作,直到parent的左孩子不存在
- parent右孩子是否存在,存在找到左右孩子中最大的孩子,让child进行标记
- 将parent与较大的孩子child比较如果:
- parent小大于较大的孩子child,调整结束
- 否则:交换parent与较大的孩子child,交换完成之后,parent中小的元素向下移动,可能导致子树不满足堆的性质,因此需要继续向下调整,即parent = child;child = parent*2+1; 然后继续2(上面的)。
图解
{ 27,15,19,18,28,34,65,49,25,37 }
len: 数组的长度
parent: 表示指向需要调整的节点指针
child: 表示指向孩子节点的指针
最后一个非叶子节点: 根据公式parent = (child-1)/2 在这里child表示最后一个节点的索引
parent = (len - 1 - 1)/2 = 4 我们应该从4索引开始进行向下调整
进行到这里左子树宣告调整完毕,开始进行右子树的调整
调整完毕!
代码实现
java
private void shiftDown(int parent, int len) {
int child = 2 * parent + 1;
// 对交换引起的堆结构的改变进行调整(如果改变就调整)
while (child < len) {
// 找出左右孩子中最大的孩子,用child进行记录
if (child + 1 < len && elem[child] < elem[child + 1]) {
child++;
}
// 判断大小关系
if (elem[child] > elem[parent]) {
swap(child,parent);
// parent中大的元素往下移动,可能会造成子树不满足堆的性质,因此需要继续向下调整
parent = child;
child = 2 * parent + 1;
} else {
// 左孩子为空,表示以最开始的parent为根的二叉树已经是大根堆结构
break;
}
}
}
堆的创建
java
public void createHeap() {
// 找倒数第一个非叶子节点,从该节点位置开始往前一直到根节点,遇到一个节点,应用向下调整
for (int parent = (size - 1 - 1) / 2; parent >= 0; parent--) {
shiftDown(parent, size);
}
}
堆的删除
注意:堆的删除一定删除的是堆顶元素。具体如下:
-
将堆顶元素对堆中最后一个元素交换
-
将堆中有效数据个数减少一个
-
对堆顶元素进行向下调整
java
public int poll(){
int temp = elem[0];
swap(0, size);
size--;
// 调整完之后需要进行先下调整,因为原来的最后一个元素变成了堆顶元素,不用想的肯定不满足大根堆的结构
shiftDown(0, size);
return temp;
}
向上调整
在最大堆中,向上调整的过程是将当前节点与其父节点进行比较,如果当前节点大于其父节点,就将它们交换位置。然后,继续向上比较和交换,直到当前节点不再大于其父节点或者已经到达根节点。
java
private void shiftUp(int child) {
while (child != 0) {
int parent = (child - 1) / 2;
if (elem[parent] < elem[child]) {
swap(child,parent);
child = parent;
} else {
break;
}
}
}
堆的插入
堆的插入总共需要两个步骤:
-
先将元素放入到底层空间中(注意:空间不够时需要扩容)
-
将最后新插入的节点向上调整,直到满足堆的性质
小根堆中插入10
java
public void offer(int val) {
if (isFull()) {
this.elem = Arrays.copyOf(this.elem, 2 * this.elem.length);
}
elem[size] = val;
shiftUp(size);
size++;
}
总代码
java
public class BigHeap {
int[] elem;
int size;
public BigHeap(int capacity) {
elem = new int[capacity];
}
public void initHeap(int[] arr) {
for (int i = 0; i < arr.length; i++) {
elem[i] = arr[i];
size++;
}
}
public void createHeap() {
for (int parent = (size - 1 - 1) / 2; parent >= 0; parent--) {
shiftDown(parent, size);
}
}
public int poll(){
int temp = elem[0];
swap(0, size);
size--;
// 调整完之后需要进行先下调整,因为原来的最后一个元素变成了堆顶元素,不用想的肯定不满足大根堆的结构
shiftDown(0, size);
return temp;
}
private void shiftDown(int parent, int len) {
int child = 2 * parent + 1;
// 对交换引起的堆结构的改变进行调整(如果改变就调整)
while (child < len) {
// 找出左右孩子中最大的孩子,用child进行记录
if (child + 1 < len && elem[child] < elem[child + 1]) {
child++;
}
// 判断大小关系
if (elem[child] > elem[parent]) {
swap(child,parent);
// parent中大的元素往下移动,可能会造成子树不满足堆的性质,因此需要继续向下调整
parent = child;
child = 2 * parent + 1;
} else {
// 左孩子为空,表示以最开始的parent为根的二叉树已经是大根堆结构
break;
}
}
}
public void offer(int val) {
if (isFull()) {
this.elem = Arrays.copyOf(this.elem, 2 * this.elem.length);
}
elem[size] = val;
shiftUp(size);
size++;
}
private void shiftUp(int child) {
while (child != 0) {
int parent = (child - 1) / 2;
if (elem[parent] < elem[child]) {
swap(child,parent);
child = parent;
} else {
break;
}
}
}
public boolean isFull() {
return elem.length == size;
}
public void swap(int i,int j){
int temp = elem[i];
elem[i] = elem[j];
elem[j] = temp;
}
}
三 . 优先级队列
前面介绍过队列,队列是一种先进先出(FIFO)的数据结构,但有些情况下,操作的数据可能带有优先级,一般出队 列时,可能需要优先级高的元素先出队列,该中场景下,使用队列显然不合适,比如:在手机上玩游戏的时候,如果有来电,那么系统应该优先处理打进来的电话;初中那会班主任排座位时可能会让成绩好的同学先挑座位。 在这种情况下,数据结构应该提供两个最基本的操作,一个是返回最高优先级对象,一个是添加新的对象。这种数 据结构就是优先级队列(Priority Queue)。
优先级队列可以用于很多场景,例如任务调度、进程调度、事件处理等。在任务调度中,可以根据任务的优先级来决定先执行哪些任务;在进程调度中,可以根据进程的优先级来决定先执行哪些进程;在事件处理中,可以根据事件的优先级来决定先处理哪些事件。
在实际应用中,优先级队列可以通过使用堆来实现,因为堆具有良好的时间复杂度和空间复杂度。通过使用堆来实现优先级队列,可以在log₂ n的时间复杂度内插入和删除元素,以及在O(1)的时间复杂度内获取优先级最高的元素。
注意点:
-
使用时必须导入PriorityQueue所在的包
-
PriorityQueue中放置的元素必须要能够比较大小,不能插入无法比较大小的对象,否则会抛出 ClassCastException异常
-
不能插入null对象,否则会抛出NullPointerException
-
没有容量限制,可以插入任意多个元素,其内部可以自动扩容
-
插入和删除元素的时间复杂度为O(log₂ n)
-
PriorityQueue底层使用了堆数据结构
-
PriorityQueue默认情况下是小堆---即每次获取到的元素都是最小的元素
堆模拟实现优先级队列
java
class MyPriorityQueue {
// 演示作用,不再考虑扩容部分的代码
private int[] array = new int[100];
private int size = 0;
public void offer(int e) {
array[size++] = e;
shiftUp(size - 1);
}
public int poll() {
int oldValue = array[0];
array[0] = array[size--];
shiftDown((size-1-1)/2,size);
return oldValue;
}
public int peek() {
return array[0];
}
}
总结
这篇文章给大家重点讲解了堆的模拟实现还有其应用之一 优先级队列,大家好好理解,我们下一篇博客见。