队列与优先队列
优先队列是队列的一种。两者的区别如下:
普通队列 | 先进先出 |
优先队列 | 根据优先级决定谁先出 |
从模板参数上去看优先队列比队列多了一个模板类less,这个less主要是为了实现伪函数,而这个仿函数则是规定优先级高低的规则。优先规则也可以根据需要进行自定义。
int main() {
//完整地写出来如下
queue<int, vector<int>> q1;
priority_queue<int, vector<int>, less<int>> q2;
//由于存在默认参数,也可以这样写
queue<int> q1; //默认使用vector向量作为容器
priority_queue<int> q2; //默认使用vector向量作为容器的同时,默认less为优先级规则
return 0;
}
在接口的使用上完全一致,只是优先队列有出队列的优先级限制。
仿函数
为什么说是仿函数(也可以叫伪函数)呢,因为他实际上是一个重载了()的类。而调用时则是创建一个对象,让对象去调用重载的()。对比函数指针,其拥有更好的适配性。
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;
}
};
int main()
{
_less<int> com1;
cout << com1(1, 2) << endl;
_greater<int> com2;
cout << com2(1, 2) << endl;
}
- priority_queue<int, vector<int>, less<int>> 谁最大,谁先出队列
- priority_queue<int, vector<int>, greater<int>> 谁最小,谁先出队列
所以,完全可以将其当作堆来用。
代码实现
完整代码:
#pragma once
#include <iostream>
#include<vector>
#include<functional>
using namespace std;
namespace bit
{
template <class T, class Container = vector<T>, class Compare = less<T> >
class priority_queue
{
public:
priority_queue()
:c(Container())
,comp(Compare())
{}
template <class InputIterator>
priority_queue(InputIterator first, InputIterator last)
: c(Container())
, comp(Compare())
{
while (first < last)
{
push(*first);
first++;
}
}
bool empty() const
{
return c.empty();
}
size_t size() const
{
return c.size();
}
const T& top() const
{
return c[0];
}
void push(const T& x)
{
c.push_back(x);
adjust_up(c.size() - 1);
}
void pop()
{
swap(c[0], c[c.size() - 1]);
c.pop_back();
adjust_down(0);
}
private:
//向下调整(参考堆)
void adjust_down(size_t parent)
{
size_t child = parent * 2 + 1;
while (child < c.size())
{
if (child + 1 < c.size() && comp(c[child + 1], c[child]))
{
child++;
}
if (comp(c[child], c[parent]))
{
swap(c[child], c[parent]);
parent = child;
child = parent * 2 + 1;
}
else
{
break;
}
}
}
//向上调整(参考堆)
void adjust_up(size_t child)
{
size_t parent = (child - 1) / 2;
while (child > 0)
{
if (comp(c[child], c[parent]))
{
swap(c[child], c[parent]);
child = parent;
parent = (child - 1) / 2;
}
else
{
break;
}
}
}
Container c;
Compare comp;
};
};
向上调整/向下调整参考 堆:
数据结构——堆与堆排序-CSDN博客https://blog.csdn.net/Dreamswi/article/details/135577317?spm=1001.2014.3001.5502