STL讲解——priority_queue的实现
优先级队列
- 优先队列是一种容器适配器,根据严格的弱排序标准,它的第一个元素总是它所包含的元素中最大的。
- 此上下文类似于堆,在堆中可以随时插入元素,并且只能检索最大堆元素(优先队列中位于顶部的元
素)。 - 优先队列被实现为容器适配器,容器适配器即将特定容器类封装作为其底层容器类,queue提供一组特
定的成员函数来访问其元素。元素从特定容器的“尾部”弹出,其称为优先队列的顶部。 - 底层容器可以是任何标准容器类模板,也可以是其他特定设计的容器类。容器应该可以通过随机访问迭
代器访问,并支持以下操作:
empty():检测容器是否为空
size():返回容器中有效元素个数
front():返回容器中第一个元素的引用
push_back():在容器尾部插入元素
pop_back():删除容器尾部元素 - 标准容器类vector和deque满足这些需求。默认情况下,如果没有为特定的priority_queue类实例化指
定容器类,则使用vector。 - 需要支持随机访问迭代器,以便始终在内部保持堆结构。容器适配器通过在需要时自动调用算法函数
make_heap、push_heap和pop_heap来自动完成此操作。
实现方法
优先级队列默认使用vector作为其底层存储数据的容器,在vector上又使用了堆算法将vector中元素构造成堆的结构,因此priority_queue就是堆,所有需要用到堆的位置,都可以考虑使用priority_queue。注意:默认情况下priority_queue是大堆。
归根结底:
我们就是用vector作为适配器实现一个大堆。
使用堆算法就是进行parent和child的比较,不满足条件就交换parent和child。
重要的接口:
堆的特性:pop的是堆顶,不是堆尾
代码讲解
首先声明
默认的堆是一个大堆,但是我今天设计的是一个默认小堆的函数,而且我的lesser是小堆比较,这是因为和单词进行对比更容易上手理解。(记住与实际相反就好了,实际中less是大堆,greater是小堆)
#pragma once
#include<iostream>
#include<vector>
#include<functional>
using namespace std;
namespace tom
{
template <class T, class Container = vector<T>, class Compare = lesser<T> >
class priority_queue
{
public:
priority_queue()
:c()
{
}
template <class InputIterator>
priority_queue(InputIterator first, InputIterator last)
:c(first,last)
{
int sz = c.size();
int root = (sz-1)/ 2;//parent=(child-1)/2 ; child=(parent+1)*2;
while (root >= 0)
{
AdjustDown(root);
root--;
}
}
bool empty() const
{
return c.empty();
}
size_t size() const
{
return c.size();
}
const T& top() const
{
if (!c.empty())
return c[0];//c.front();
else
cout << "空堆,请插入元素!" << endl;
}
void push(const T& x)
{
c.push_back(x);
AdjustUP(c.size() - 1);
}
void pop()//堆一般都是pop头的,pop尾没啥意思
{
if (!empty())
{
swap(c.front(), c.back());//swap(c[0], c[c.size()-1]);
c.pop_back();
AdjustDown(0);
}
}
private:
Container c;
Compare comp;
};
};
先构建一个命名空间这是一个良好的习惯
设计一个类priority_queue剩下的就交给vector了,因为stl会把你给的数据直接初始化的;
但是要进行堆的排序还是需要向下调整的(AdjustDown)于是乎要设计一个函数AdjustDown;
并且删除数据或者插入数据都需要调整,于是乎在设计一个函数AdjustUp进行向上调整;
适配器
template <class T, class Container = vector<T>, class Compare = lesser<T> >
class priority_queue
{
...
}
这里的 class Container 就是一个适配器模板,c++不仅给了参数模板,还给了适配器模板,太逆天了!!!
这个适配器模板可以根据你的需求进行更改,比如改为deque,但是我们给了缺省值(默认就用vector适配器了)。
需要设计一个迭代器赋值构造其实是复用了vector的构造函数。
向上、下调整
// 向上调整
void AdjustUP(int child)
{
int parent = ((child - 1) >> 1);
while (child)
{
if (c[child]<c[parent])
{
swap(c[child], c[parent]);
child = parent;
parent = ((child - 1) >> 1);
}
else
return;
}
}
// 向下调整
void AdjustDown(int parent)
{
int child = (parent)*2+1;
//parent = child / 2 - 1;
while (child < c.size())
{
if ((child + 1) < c.size() &&c[child + 1]<c[child])
{
child++;
}
if (c[child]<c[parent])
{
swap(c[child], c[parent]);
parent = child;
child = (parent) * 2 + 1;
}
else
return;
}
}
仿函数的构造
并不想再写一个大堆出来,因为会有代码冗余,于是乎想到了构造一个仿函数,来帮我实现大于小于的函数判断。
template<class T>
struct lesser
{
bool operator()(const T& x, const T& y)
{
return x < y;//我设计的与stl库设计的不一样,我把less设计成了小堆
}
};
template<class T>
struct greater
{
bool operator()(const T& x, const T& y)
{
return x > y;//我设计的与stl库设计的不一样,我把great设计成了大堆
}
};
template <class T, class Container = vector<T>, class Compare = lesser<T> >
class priority_queue
{
...
}
而且我在前面也留了扣子,在实现类模板的时候已经预留了compare函数了。
template <class T, class Container = vector<T>, class Compare = lesser<T> >
class priority_queue
{
...
}
其他细节
其他的细节基本没什么重点了。
代码和测试代码贴出
#pragma once
#include<iostream>
#include<vector>
#include<functional>
using namespace std;
namespace tom
{
template<class T>
struct lesser
{
bool operator()(const T& x, const T& y)
{
return x < y;//我设计的与stl库设计的不一样,我把less设计成了小堆
}
};
template<class T>
struct greater
{
bool operator()(const T& x, const T& y)
{
return x > y;//我设计的与stl库设计的不一样,我把great设计成了大堆
}
};
template <class T, class Container = vector<T>, class Compare = lesser<T> >
class priority_queue
{
public:
priority_queue()
:c()
{
}
template <class InputIterator>
priority_queue(InputIterator first, InputIterator last)
:c(first,last)
{
int sz = c.size();
int root = (sz-1)/ 2;//parent=(child-1)/2 ; child=(parent+1)*2;
while (root >= 0)
{
AdjustDown(root);
root--;
}
}
bool empty() const
{
return c.empty();
}
size_t size() const
{
return c.size();
}
const T& top() const
{
if (!c.empty())
return c[0];//c.front();
else
cout << "空堆,请插入元素!" << endl;
}
void push(const T& x)
{
c.push_back(x);
AdjustUP(c.size() - 1);
}
void pop()//堆一般都是pop头的,pop尾没啥意思
{
if (!empty())
{
swap(c.front(), c.back());//swap(c[0], c[c.size()-1]);
c.pop_back();
AdjustDown(0);
}
}
// 向上调整
void AdjustUP(int child)
{
int parent = ((child - 1) >> 1);
while (child)
{
if (Compare()(c[child] , c[parent]))
//if (c[child]<c[parent])
{
swap(c[child], c[parent]);
child = parent;
parent = ((child - 1) >> 1);
}
else
return;
}
}
// 向下调整
void AdjustDown(int parent)
{
int child = (parent)*2+1;
//parent = child / 2 - 1;
while (child < c.size())
{
if ((child + 1) < c.size() &&Compare()( c[child + 1],c[child]))
//if ((child + 1) < c.size() &&c[child + 1]<c[child])
{
child++;
}
if (Compare()(c[child] , c[parent]))
//if (c[child]<c[parent])
{
swap(c[child], c[parent]);
parent = child;
child = (parent) * 2 + 1;
}
else
return;
}
}
private:
Container c;
Compare comp;
};
};
实现一个大堆
实现一个默认的小堆