一、优先级队列
① 什么是优先级队列？
在此之前，我们已经学习过了**"队列"** 的相关知识，我们知道"队列"是一种"先进先出"的数据结构 ，我们还学习过**"栈"** ，是"后进先出"的数据结构 ，这两种数据结构通常能够帮助我们在解题时存储一些数据 ，但是经过一段时间的练习，我们应该也能意识到这两种数据结构的缺点："不够灵活"。
因为在有些情况下，我们要存储的数据并非是只存取队头或者队尾，有时我们还想使数据拥有一种排序的规律，使得我们能够随时取出和存入"按照这种规律下，优先级较高的数据"，而想要实现这一点，即便是"栈"与"队列"两者的结合"双端队列"，都是无法轻易办到的。
📚 比如：有时考试我们会按照学生的成绩进行分配考场，想在一个考场中提出或者放入一个学生，就要根据他的考试成绩来判断。
于是------优先级队列( PriorityQueue)出现了
二、优先级队列的模拟实现
优先级队列是一种能够按照指定的排序方式，自动将数据存到合理的位置的数据结构。它的底层实际上就是通过类似二叉树的结构来实现的~
++优先级队列可以分为两种++：
📕 大根堆(这棵二叉树中，每棵树的根节点都比它左右子树的根节点大)
📕 小根堆(这棵二叉树中，每棵树的根节点都比它左右子树的根节点小)
(需要注意的是：根总是一棵完全二叉树)
📚 比如：此时我们有一组数据为{10，7，12，6，8，4}，那么按照小根堆的形式存储它，就是：
这样的一颗二叉树，那么接下来我们一点点的去探究，优先级队列究竟是如何实现的：
① 基本框架
(java默认的优先级队列为小根堆，所以我们这里尝试模拟实现一个大根堆)
与之前一些数据结构的模拟实现较为类似，由于"堆"是一棵完全二叉树，所以这里我们的模拟实现就不再使用链表了。而是直接使用数组进行实现(通过层序遍历的顺序)，所以我们需要最基本的一个整数数组elem，还需要一个记录有效数据个数的usedSize~
java
import java.util.*;
public class MyHeap {
public int[] elem;
public int usedSize;
public MyHeap() {
}
//对elem进行初始化
public void init(int[] array) {
}
//创建一个优先级队列
public void createHeap(int[] array) {
}
//向下调整
private void shiftDown(int root,int len) {
}
//元素入队(不破坏优先级队列结构)
public void push(int val) {
}
//向上调整
private void shiftUp(int child) {
}
//判满
public boolean isFull() {
}
//出队
public void pollHeap() {
}
//判空
public boolean isEmpty() {
}
//获取队顶元素
public int peekHeap() {
}
}② 初始化elem
📚 ++思路提示++：
该方法用于我们先将数组存入elem中，以便我们后续的操作，我们只需要将数组中的元素存入elem，并且在初始化elem途中，适时的对elem进行扩容即可~
📖 ++代码示例++：
java
//对elem进行初始化
public void init(int[] array) {
int len = array.length;
for (int i = 0; i < len; i++) {
if (isFull()) {
elem = Arrays.copyOf(elem, elem.length * 2);
}
elem[i] = array[i];
usedSize++;
}
}
java
//判满
public boolean isFull() {
return usedSize == elem.length;
}③ 堆的向下调整
📚 ++思路提示++：
想要创建一个大根堆，就需要我们上面提到的大根堆性质"每棵树的根节点都比它左右子树的根节点大"
而想要使我们的elem中的元素也遵从这种规律，我们就要知道应该如何去对堆中的元素位置进行调整。其实还是比较简单的：
📚 对于具有n个结点的完全二叉树，如果按照从上至下从左至右的顺序对所有结点从0开始编号，则对于序号为i的结点有以下性质：
📕 若孩子节点下标为 i ，那么父亲结点为 (i - 1) / 2 [i > 0]
📕 若父亲节点下标为 i ，那么左孩子节点为 2 * i + 1 [2i + 1 < n]，右孩子节点为 2 * i + 2 [2i + 2 < n]
📕首先，将需要调整的元素下标记作parent
📕 如果parent存在左孩子，则通过公式，算出parent的左孩子结点child
📕 如果有两个孩子结点，则将孩子结点标记为值最大的孩子
📕 判断孩子结点与父亲结点的大小，如果孩子更大，则交换孩子与父亲结点(大根堆)
📕 如果交换了结点，则将parent标记为child，再重新求child
⭐ ++图示++：
📖 ++代码示例++：
java
//向下调整
private void shiftDown(int parent,int len) {
int child = parent * 2 + 1;
while(child < len){
//判断是否有右孩子,并且右孩子是否更大
if(child + 1 < len && elem[child + 1] > elem[child]){
child++;
}
if(elem[child] > elem[parent]){
swap(elem,child,parent);
parent = child;
child = parent * 2 + 1;
}else {
break;
}
}
}
java
public void swap(int[] arr,int i,int j){
int tmp = arr[i];
arr[i] = arr[j];
arr[j] = tmp;
}
④ 堆的创建
📚 ++思路提示++：
我们刚刚所实现的"向下调整"，其实就是为了这一步我们成功的构建出一个"大根堆"而进行的铺垫
我们可以注意到，在上面的"向上调整"中，我们每一次进行交换，其实就是创建出了一个"这三个元素组成的局部大根堆"，而想将整个数组都变成大根堆，我们就可以对数组中每一个有子节点的根进行向下调整~
📖 ++代码示例++：
java
//创建一个优先级队列
public void createHeap() {
int len = elem.length;
int parent = (elem.length - 1 - 1) / 2;
for(int i = parent;i >= 0;i--){
shiftDown(i,len);
}
}这里或许大家会有一个疑问：为什么从最后一个根节点向上调整，而不是从第一个根节点向下调整？这是因为，两种看似一样的方法，其实时间复杂度相差并不小：
📕 ++如果从第一个根节点开始向下调整++：
对于根节点（位于第 1 层），它可能需要向下调整到叶子节点（第 log n 层），因此调整的时间复杂度是 O(log n)。
对于第 2 层的节点，它们可能需要向下调整到第 log n - 1 层，时间复杂度是 O(log n - 1)。
以此类推，直到叶子节点（不需要调整）。
这种方式的调整，时间复杂度为O(nlogn)
📕 ++如果从最后一个根节点向上调整++：
直接能够越过所有的叶子节点（最好的情况占结点总数一半 + 1）
对于剩余的结点，调整取决于它们的高度，并且越接近根节点，需要调整的高度越低。
这种方式的调整，时间复杂度接近O(n)
⑤ 堆的插入
📚 ++思路提示++：
顾名思义，就是在堆中插入一个元素，但是我们需要注意的是，不论是此刻的插入，亦或是之后我们需要进行的删除，都要保证操作后仍然为大根堆。所以在我们将新的元素插入到堆的末尾后，还要将该元素不断地向上进行调整，直到在某一刻符合大根堆的条件，停止调整。
📕对堆进行判满，如果堆已满则进行扩容
📕 将新的元素插入堆的末尾，usedSize++
📕 对新元素进行向上调整：
📕 将元素下标标记为child，并且通过公式求出它的parent
📕如果 parent >= 0 判断child和parent的值，如果child更大，两者进行交换 ，否则调整结束
(因为在此之前，已经是标准的大根堆，所以不需要进行两个child的判断，只调整目标结点即可)
📕 如果进行了交换，则再将parent = child，然后重新求parent
⭐ ++图示++：
📖 ++代码示例++：
java
//元素入队(不破坏优先级队列结构)
public void push(int val) {
if(isFull()){
elem = Arrays.copyOf(elem, elem.length * 2);
}
elem[usedSize] = val;
shiftUp(usedSize++);
}
java
//向上调整
private void shiftUp(int child) {
int parent = (child - 1) / 2;
while(parent >= 0){
if(elem[child] > elem[parent]){
swap(elem,child,parent);
child = parent;
parent = (child - 1) / 2;
}else {
break;
}
}
}
⑥ 堆的删除
(注意：堆的删除指的是删除堆顶元素)
📚 ++思路提示++：
想要删除一个堆顶元素，我们首先知道的是"usedSize"需要减一 ，那么我们由这点思考一下，如果不进行任何操作，首先usedSize--后，我们的堆中实际上消失的是哪个元素？没错，就是堆中的最后一个元素~，但是我们想删除的并不是该元素，而是我们的堆顶元素，简单呀~将这两个元素互换一下不就好了~最后再将新的堆顶元素进行向下调整即可~
📕 首先，判断该堆是否为空，若为空则直接退出该方法
📕将堆顶元素与堆中最后一个元素进行交换
📕 然后将usedSize--
📕 最后将新的堆顶元素进行向下调整
⭐ ++图示++：
📖 ++代码示例++：
java
//出队
public void pollHeap() {
if(isEmpty()){
return;
}
swap(elem,0,--usedSize);
shiftDown(0,usedSize);
}
java
//判空
public boolean isEmpty() {
return usedSize == 0;
}
java
//获取队顶元素
public int peekHeap() {
return elem[0];
}
完整代码：
java
import java.util.*;
public class MyHeap {
public int[] elem;
public int usedSize;
public MyHeap(){
elem = new int[10];
}
//创建一个大根堆
public void creative(int[] arr){
for(int i = 0;i < arr.length;i++){
if(isFull()){
elem = Arrays.copyOf(elem,elem.length * 2);
}
elem[i] = arr[i];
usedSize++;
}
}
public void doArr(){
//最后一个叶子结点的父结点
int start = (usedSize - 1 - 1) / 2;
for(int i = start;i >= 0;i--){
siftDown(i,usedSize);
}
}
//将较大的子节点与父结点交换
//向下调整
public void siftDown(int parent,int end){
//找到父结点的的左子结点
int child = parent * 2 + 1;
//保证该子结点未越界
while(child < end){
//查找左右子结点中的最大子结点
//(包含了找出最大值后,对右子节点的判断)
if(child + 1 < end && 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 = parent * 2 + 1;
}else {
break;
}
}
}
//向堆中添加新元素
public void offer(int val){
if(isFull()){
elem = Arrays.copyOf(elem,elem.length * 2);
}
elem[usedSize] = val;
siftUp(usedSize);
usedSize++;
}
//向上调整
public void siftUp(int child){
int parent = (child - 1) / 2;
while(parent >= 0){
if(elem[child] > elem[parent]){
int tmp = elem[child];
elem[child] = elem[parent];
elem[parent] = tmp;
child = parent;
parent = (child - 1) / 2;
}else {
break;
}
}
}
//删除元素
public int poll(){
int oldValue = elem[0];
elem[0] = elem[--usedSize];
siftDown(0,usedSize);
return oldValue;
}
//将堆排序成从小到大的顺序
public void heapSort(){
int end = usedSize - 1;
while(end > 0){
int tmp = elem[end];
elem[end] = elem[0];
elem[0] = tmp;
siftDown(0,end);
end--;
}
}
public boolean isFull(){
return usedSize >= elem.length;
}
}这篇文章我们对"优先级队列"进行了基本的认识，并且自己也尝试着模拟实现了一个大根堆，关于"优先级队列"的后续知识我将在后面的文章中为大家讲解，那么这篇文章到这里就结束啦，作者能力有限，如果有哪里说的不够清楚或者不够准确，还请各位在评论区多多指出，我也会虚心学习的，我们下次再见啦