文章目录
⭐前言
首先在进入优先级队列的学习之前,我们需要先对优先级队列有一定的了解。
优先级队列是容器适配器中的一种,元素在队列中的顺序是按照它们的优先级来排列的,而不是按照它们被插入的队列的顺序。这其实就是数据结构中的堆,其底层都是以数组存储的完全二叉树,下面就来详细了解一下priority-queue是如何进行使用的。
🏠一、priority-queue的介绍
Priority Queue(优先级队列) 是一种特别的数据结构,它为队列中的每个元素都分配了一个优先级。在这个队列里,元素并非按照被插入的顺序来排列,而是依据它们的优先级来排序。这意味着,具有最高优先级的元素会最先被处理或移除,而优先级最低的元素则会最后被处理。它的底层实现通常使用堆这一数据结构。
🎄二、priority-queue的使用
优先级队列默认使用vector作为其底层存储数据的容器,在vector上又使用了堆算法将vector中元素构造成堆的结构,因此priority_queue就是堆,所有需要用到堆的位置,都可以考虑使用priority_queue。注意:默认情况下priority_queue是大堆。
🎡三、priority-queue的模拟实现
我们还是根据库中操作,把它实现成一个容器适配器的类模板:
namespace bit
{
template<class T,class Container = vector<T>>
class priority_queue
{
public:
private:
Container _con;
};
}
后面会讲到第三个模板参数及比较的仿函数。
1. 基本框架
我们首先来实现一下它的基本核心接口:
1.push
我们在push的时候先尾插一个数据,然后在对它进行向上调整操作。
void push(const T& x)
{
_con.push_back(x);
Adjustup(_con.size() - 1);
}
2.pop
我们在之前实现堆的删除时,是不是将堆顶的数据跟最后一个数据进行交换,然后删除数组的最后一个数据,最后再进行向下调整操作。
void pop()
{
swap(_con[0], _con[_con.size() - 1]);
_con.pop_back();
AdjustDown(0);
}
3.top
返回队列的第一个数据。
const T& top()
{
return _con[0];
}
4.size
返回队列中有效数据的大小
size_t size() const
{
return _con.size();
}
5.empty
判断队列是否为空
bool empty() const
{
return _con.empty();
}
2. 向上调整
我们默认先按大堆来进行调整。
向上调整之前要保证之前的数据必须是一个堆。插入的数据首先会被放置在堆的末尾,然后看插入的数据是否满足对应大堆的性质,不满足就进行交换,直到满足就停止。
void Adjustup(int child)
{
int parent = (child - 1) / 2;
while (child > 0)
{
if (_con[parent] < _con[child])
{
swap(_con[child], _con[parent]);
child = parent;
parent = (child - 1) / 2;
}
else
{
break;
}
}
}
3. 向下调整
其调整思路和向上调整类似,只不过它是从上往下进行调整。
过程:从根节点开始选出左右孩子节点较小的那一个,让父亲节点与该节点进行比较,如果小于该节点则进行交换,大于则不交换,不断循环此过程,直到符合父亲节点大于等于孩子节点时则停止。
void AdjustDown(int parent)
{
size_t child = parent * 2 + 1;
while (child < _con.size())
{
if (child + 1 < _con.size() && _con[child] < _con[child + 1])
{
++child;
}
if (_con[parent] < _con[child])
{
swap(_con[child], _con[parent]);
parent = child;
child = parent * 2 + 1;
}
else
{
break;
}
}
}
🚀四、仿函数的介绍
仿函数(Functor)是一种编程概念,它指的是一种重载了函数调用运算符operator()的类或结构体,因从而可以像普通函数一样被调用。
priority-queue中的仿函数
我们在上述实现了默认是大堆的情况下,如果我们想要小堆该怎么办呢?
之前我们在学习堆的过程中就知道,只需把向上或向下调整的比较符号改成相反的就可以了。但是我们通过学习仿函数,我们就可以通过传仿函数去控制大小堆的变化。
template<class T>
class Less
{
public:
bool operator()(const T& x, const T& y)
{
return x < y;
}
};
template<class T>
class Greater
{
public:
bool operator()(const T& x, const T& y)
{
return x > y;
}
};
我们默认Less是大堆,Greater是小堆。
那我们该怎么使用第三个参数呢?我们只需和库中保持一致即可,默认第三个参数为
class compare的缺省参数为仿函数Less即可。
template<class T,class Container = vector<T>,class compare = Less<T>>
class priority_queue
{
public:
//向上调整
void Adjustup(int child)
{
compare com;
int parent = (child - 1) / 2;
while (child > 0)
{
//if (_con[parent] < _con[child])
if(com(_con[parent] , _con[child]))
{
swap(_con[child], _con[parent]);
child = parent;
parent = (child - 1) / 2;
}
else
{
break;
}
}
}
//向下调整
void AdjustDown(int parent)
{
size_t child = parent * 2 + 1;
compare com;
while (child < _con.size())
{
//if (child + 1 < _con.size() && _con[child] < _con[child + 1])
if (child + 1 < _con.size() && com(_con[child] , _con[child + 1]))
{
++child;
}
//if (_con[parent] < _con[child])
if(com(_con[parent], _con[child]))
{
swap(_con[child], _con[parent]);
parent = child;
child = parent * 2 + 1;
}
else
{
break;
}
}
}
这样做我们就可以通过仿函数来控制大小堆的变化。
我们下面就可以通过代码来演示一下:
现在先用默认为大堆的情况下:
如果我们想要在小堆的情况下,只需把less改成greater即可。
🏝️五、总结及源代码
通过上述学习,我们总结一下知识点:
1.优先级队列是一种容器适配器,其底层就是堆这一结构。
2.默认情况下,优先级队列为大堆。
3.队列中的元素具有优先级,优先级高的元素先出队。优先级相同的元素则按照先进先出的方式处理。
4.允许队列在任意位置插入数据,但出队时则先移除优先级较高的元素。
priority-queue.cpp
template<class T>
class Less
{
public:
bool operator()(const T& x, const T& y)
{
return x < y;
}
};
template<class T>
class Greater
{
public:
bool operator()(const T& x, const T& y)
{
return x > y;
}
};
namespace bit
{
template<class T,class Container = vector<T>,class compare = Less<T>>
class priority_queue
{
public:
void Adjustup(int child)
{
compare com;
int parent = (child - 1) / 2;
while (child > 0)
{
if(com(_con[parent] , _con[child]))
{
swap(_con[child], _con[parent]);
child = parent;
parent = (child - 1) / 2;
}
else
{
break;
}
}
}
void push(const T& x)
{
_con.push_back(x);
Adjustup(_con.size() - 1);
}
void AdjustDown(int parent)
{
size_t child = parent * 2 + 1;
compare com;
while (child < _con.size())
{
if (child + 1 < _con.size() && com(_con[child] , _con[child + 1]))
{
++child;
}
if(com(_con[parent], _con[child]))
{
swap(_con[child], _con[parent]);
parent = child;
child = parent * 2 + 1;
}
else
{
break;
}
}
}
void pop()
{
swap(_con[0], _con[_con.size() - 1]);
_con.pop_back();
AdjustDown(0);
}
const T& top()
{
return _con[0];
}
size_t size() const
{
return _con.size();
}
bool empty() const
{
return _con.empty();
}
private:
Container _con;
};
}