目录
适配器是一种设计模式(设计模式是一套被反复使用的、多数人知晓的、经过分类编目的、代码设计经验的总结)，该种模式是将一个类的接口转换成客户希望的另外一个接口。
stack和queue中也可以存放元素，但在STL中并没有将其划分在容器的行列，而是将其称为容器适配器，这是因为stack和队列只是对其他容器的接口进行了包装。
一. stack
栈在初阶数据结构已经很熟悉了，这里不过是用C++再了解栈
-
stack是一种容器适配器，专门用在具有后进先出操作的上下文环境中，其删除只能从容器的一端进行元素的插入与提取操作。
-
stack是作为容器适配器被实现的，容器适配器即是对特定类封装作为其底层的容器，并提供一组特定的成员函数来访问其元素，将特定类作为其底层的，元素特定容器的尾部(即栈顶)被压入和弹出。
-
stack的底层容器可以是任何标准的容器类模板或者一些其他特定的容器类，这些容器类应该支持以下操作：
-
empty：判空操作
-
back：获取尾部元素操作
-
push_back：尾部插入元素操作
-
pop_back：尾部删除元素操作
标准容器vector、deque、list均符合这些需求，默认情况下，如果没有为stack指定特定的底层容器， 默认情况下使用deque
没什么很大的区别，只是套用了别的容器，这里直接放代码：
template<class T, class Container = deque<T>>
class stack
{
public:
bool empty()
{
return con.empty();
}
size_t size()
{
return con.size();
}
void push(const T& x)
{
con.push_back(x);
}
void pop()
{
con.pop_back();
}
T& top()
{
return con.back();
}
const T& top() const
{
return con.back();
}
private:
Container con;
};二. queue
这里和上面同理。
- 队列是一种容器适配器，专门用于在FIFO上下文(先进先出)中操作，其中从容器一端插入元素，另一端提取元素。
- 队列作为容器适配器实现，容器适配器即将特定容器类封装作为其底层容器类，queue提供一组特定的成员函数来访问其元素。元素从队尾入队列，从队头出队列。
- 底层容器可以是标准容器类模板之一，也可以是其他专门设计的容器类。该底层容器应至少支持以下操作:
- empty：检测队列是否为空
- size：返回队列中有效元素的个数
- front：返回队头元素的引用
- back：返回队尾元素的引用
- push_back：在队列尾部入队列
- pop_front：在队列头部出队列
标准容器类deque和list满足了这些要求。默认情况下，如果没有为queue实例化指定容器类，则使用标准容器deque。
直接上代码：
template <class T, class Container = deque<T>>
class queue
{
public:
bool empty()
{
return con.empty();
}
size_t size()
{
return con.size();
}
void push(const T& x)
{
con.push_back(x);
}
T& front()
{
return con.front();
}
const T& front() const
{
return con.front();
}
T& back()
{
return con.back();
}
const T& back() const
{
return con.back();
}
void pop()
{
con.pop_front();
}
private:
Container con;
};三. priority_queue
着重说一下优先级队列，这是接触到C++的第三个容器适配器
- 优先队列是一种容器适配器，根据严格的弱排序标准，它的第一个元素总是它所包含的元素中最大的。
- 此上下文类似于堆，在堆中可以随时插入元素，并且只能检索最大堆元素(优先队列中位于顶部的元素)。
- 优先队列被实现为容器适配器，容器适配器即将特定容器类封装作为其底层容器类，queue提供一组特定的成员函数来访问其元素。元素从特定容器的“尾部”弹出，其称为优先队列的顶部。
- 底层容器可以是任何标准容器类模板，也可以是其他特定设计的容器类。容器应该可以通过随机访问迭代器访问，并支持以下操作：
- empty()：检测容器是否为空
- size()：返回容器中有效元素个数
- front()：返回容器中第一个元素的引用
- push_back()：在容器尾部插入元素
- pop_back()：删除容器尾部元素
标准容器类vector和deque满足这些需求。默认情况下，如果没有为特定的priority_queue类实例化指定容器类，则使用vector。
注意：需要支持随机访问迭代器，以便始终在内部保持堆结构。容器适配器通过在需要时自动调用算法函数make_heap、push_heap和pop_heap来自动完成此操作。
也就是说：priority_queue在vector上使用了堆算法将vector中元素构造成堆的结构，因此priority_queue就是堆，所有需要用到堆的位置，都可以考虑使用priority_queue。
注意：默认情况下priority_queue是大堆。（优先级队列默认大的优先级高，传的是less仿函数，底层是一个大堆，想控制小的优先级搞传greater仿函数，底层是一个小堆）
如下：
#include <vector>
#include <queue>
#include <functional> //greater算法的头文件
void TestPriorityQueue()
{
// 默认情况下，创建的是大堆，其底层按照小于号比较
vector<int> v{3,2,7,6,0,4,1,9,8,5};
priority_queue<int> q1;
for (auto& e : v)
q1.push(e);
cout << q1.top() << endl;
// 如果要创建小堆，将第三个模板参数换成greater比较方式
priority_queue<int, vector<int>, greater<int>> q2(v.begin(), v.end());
cout << q2.top() << endl;
}
如果在priority_queue中放自定义类型的数据，用户需要在自定义类型中提供>或者< 的重载。
以下是priority_queue的模板：
我们会发现第三个模板参数传入了一个比较的模板参数，也就是仿函数。
仿函数：一个声明了一个含有operator()成员函数的类，当创建好了对象后可以像函数那样使用这个对象，只不过这个函数功能是在一个类中的运算符operator()中实现，是一个函数对象，它将函数作为参数传递的方式来使用。
其实也就是说这里的比较从C语言中直接写<或者>变成了使用对象来比大小。
仿函数的实现如下：
template<class T>
struct less
{
bool operator()(const T& x, const T& y) const
{
return x < y;
}
};
template<class T>
struct greater
{
bool operator()(const T& x, const T& y) const
{
return x > y;
}
};1. empty()，top()，size()的实现
这里我们将实现empty，top，size，pop，push的接口，前三个实现没什么难度，无非是封装容器的函数，如下：
bool empty()
{
return con.empty();
}
size_t size()
{
return con.size();
}
const T& top()
{
return con[0];
}2. pop和push的实现
pop和push则会涉及到之前写的向下调整法和向上调整法。
push的实现如下：
//默认建大堆
void Adjustup(int child)
{
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& val)
{
con.push_back(val);
Adjustup(con.size() - 1);
}需要注意的是这里使用了仿函数，并且将比较对象com作为了成员变量，所以子节点和父节点在比较是像使用函数一样，这就是仿函数的特性。
pop的实现如下：
//默认建大堆
void Adjustdown(int parent)
{
size_t child = parent * 2 + 1;
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()
{
assert(!con.empty());
swap(con[0], con[con.size() - 1]);
con.pop_back();
Adjustdown(0);
}这里和向上调整法一致，是使用仿函数来控制大堆或者小堆。
PS：这里在priority_queue类里创建比较对象是为了方便与C语言中的函数指针适配，也就是说，仍然可以适配函数指针。如何适配呢？具体查看以下的构造函数的实现：
priority_queue(const compare& comfun = compare())
:com(comfun)
{}这里使用了缺省的方式，当函数指针传进来，就会被初始化nullptr，但是如果传参数的时候是这样传：
将函数名传过来而不是使用默认的，那么就可以匹配到想要的比较函数，可以正常进行比较，也就适配了函数指针。
这里再补充一个区间构造函数，既然是构造，自然也要建堆，但是这里为了效率我们使用向下调整法的方式建堆：
template <class InputIterator>
priority_queue(InputIterator first, InputIterator last, const compare& comp =
compare())
:com(comp)
{
//拷贝进入
while (first != last)
{
con.push_back(*first);
++first;
}
//建堆向下调整法，最后一个非叶子结点处开始调整
for (int i = (con.size() - 1 - 1) / 2; i >= 0; --i)
{
Adjustdown(i);
}
}自此，优先级队列也就实现完，下面是完整的代码实现方式：
template<class T>
struct less
{
bool operator()(const T& x, const T& y) const
{
return x < y;
}
};
template<class T>
struct greater
{
bool operator()(const T& x, const T& y) const
{
return x > y;
}
};
template<class T, class Container = vector<T>, class compare = less<T>>
class priority_queue
{
public:
priority_queue(const compare& comfun = compare())
:com(comfun)
{}
template <class InputIterator>
priority_queue(InputIterator first, InputIterator last, const compare& comp =
compare())
:com(comp)
{
//拷贝进入
while (first != last)
{
con.push_back(*first);
++first;
}
//建堆向下调整法，最后一个非叶子结点处开始调整
for (int i = (con.size() - 1 - 1) / 2; i >= 0; --i)
{
Adjustdown(i);
}
}
bool empty()
{
return con.empty();
}
size_t size()
{
return con.size();
}
const T& top()
{
return con[0];
}
//默认建大堆
void Adjustup(int child)
{
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& val)
{
con.push_back(val);
Adjustup(con.size() - 1);
}
//默认建大堆
void Adjustdown(int parent)
{
size_t child = parent * 2 + 1;
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()
{
assert(!con.empty());
swap(con[0], con[con.size() - 1]);
con.pop_back();
Adjustdown(0);
}
private:
compare com;
Container con;
};
625
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
