一、适配器
1.适配器定义
- 适配器是一种设计模式（设计模式使一套呗反复使用的、多数人知晓的、经过分类编目的、代码设计经验的总结），在设计模式中，存在两个接口不同的类，可以使用一个适配器类来将一个接口转换为客户希望的另一个接口。
2.三种顺序适配器
- C++标准库提供了三种顺序适配器：stack、queue、priority_queue。
- 虽然stack、queue、priority_queue中也可以存放元素，但在STL中并没有将其划分在容器的行列，而是将其称为容器适配器，这是因为每个容器在底层都有自己的实现方式，而stack、queue、priority_queue只是在底层将其他容器进行了封装。
二、stack
1.stack的定义
- stack是一种容器适配器，是只能从容器的一端进行元素的压入弹出操作。
- stack的底层容器可以使任何标准的容器类模板或者一些其他特定的容器类，这些容器类应该支持以下操作：（1）empty()：判空操作。（2）top()：获取尾部元素操作。（3）push()：尾部压入元素操作。（4）pop()：尾部弹出操作。
- 标准容器vector、deque、list都符合这些需求，如果没有为stack指定特定的底层容器，默认情况下，使用标准容器deque作为stack的底层容器。
- 详细介绍请见数据结构之栈和队列及其实现。
2.stack的使用
#include <iostream>
#include <stack>
using namespace std;
void testStack()
{
stack<int> st;
st.push(0);
st.push(1);
st.push(2);
st.push(3);
st.push(4);
st.push(5);
cout << "st的size()为：" << st.size() << endl;
cout << "top元素为： " << st.top() << endl;
while (!st.empty())
{
cout << st.top() << endl;
st.pop();
}
}
int main()
{
testStack();
return 0;
}
3.适配器stack的模拟实现
#include <iostream>
#include <vector>
#include <list>
#include <deque>
using namespace std;
namespace sheena
{
template <class T, class Container = deque<T>>
class my_stack
{
public:
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();
}
size_t size()
{
return _con.size();
}
bool empty()
{
return _con.empty();
}
private:
Container _con;
};
}
void testStack1()
{
sheena::my_stack<int, vector<int>> st;
st.push(0);
st.push(1);
st.push(2);
st.push(3);
st.push(4);
st.push(5);
cout << "st的size()为：" << st.size() << endl;
cout << "top元素为： " << st.top() << endl;
while (!st.empty())
{
cout << st.top() << endl;
st.pop();
}
}
void testStack2()
{
sheena::my_stack<int, list<int>> st;
st.push(0);
st.push(1);
st.push(2);
st.push(3);
st.push(4);
st.push(5);
cout << "st的size()为：" << st.size() << endl;
cout << "top元素为： " << st.top() << endl;
while (!st.empty())
{
cout << st.top() << endl;
st.pop();
}
}
void testStack3()
{
sheena::my_stack<int, deque<int>> st;
st.push(0);
st.push(1);
st.push(2);
st.push(3);
st.push(4);
st.push(5);
cout << "st的size()为：" << st.size() << endl;
cout << "top元素为： " << st.top() << endl;
while (!st.empty())
{
cout << st.top() << endl;
st.pop();
}
}
int main()
{
cout << "testStack1()当底层实现是容器vector：" << endl;
testStack1();
cout << endl;
cout << "testStack2()当底层实现是容器list： " << endl;
testStack2();
cout << endl;
cout << "testStack3()当底层实现是容器deque： " << endl;
testStack3();
cout << endl;
return 0;
}
三、queue
1.queue的定义
- 队列是一种容器适配器，专门用于在FIFO（先进先出）中操作，其中从容器一端插入元素，另一端提取元素。元素从队尾入队，从队头出队列。
- queue底层容器至少支持以下操作：（1）empty()：检测队列是否为空。（2）size()：返回队列中有效元素的个数。（3）front()：返回队头元素的引用。（4）back()：返回队尾元素的引用。（5）push()：在队列尾部入队列。（6）pop()：在队列头部出队列。
- 标准容器类deque和list满足了这些要求。如果没有queue实例化指定容器类，默认情况下，则使用标准容器deque。
- 详细介绍请见数据结构之栈和队列及其实现。
2.queue的使用
#include <iostream>
#include <queue>
using namespace std;
void testQueue()
{
queue<int> q;
q.push(0);
q.push(1);
q.push(2);
q.push(3);
q.push(4);
q.push(5);
cout << "q的size()为：" << q.size() << endl;
cout << "q的front队头元素为：" << q.front() << endl;
cout << "q的back队尾元素为： " << q.back() << endl;
while (!q.empty())
{
cout << q.front() << endl;
q.pop();
}
}
int main()
{
testQueue();
return 0;
}
3.适配器queue的模拟实现
#include <iostream>
#include <list>
#include <deque>
using namespace std;
namespace sheena
{
template <class T, class Container = deque<T>>
class my_queue
{
public:
void push(const T& x)
{
_con.push_back(x);
}
void pop()
{
_con.pop_front();
}
T& front()
{
return _con.front();
}
const T& front() const
{
return _con.front();
}
T& back()
{
return _con.back();
}
const T& back() const
{
return _con.back();
}
size_t size()
{
return _con.size();
}
bool empty()
{
return _con.empty();
}
private:
Container _con;
};
}
void testQueue1()
{
sheena::my_queue<int, deque<int>> q;
q.push(0);
q.push(1);
q.push(2);
q.push(3);
q.push(4);
q.push(5);
cout << "q的size()为：" << q.size() << endl;
cout << "q的front队头元素为：" << q.front() << endl;
cout << "q的back队尾元素为： " << q.back() << endl;
while (!q.empty())
{
cout << q.front() << endl;
q.pop();
}
}
void testQueue2()
{
sheena::my_queue<int, list<int>> q;
q.push(0);
q.push(1);
q.push(2);
q.push(3);
q.push(4);
q.push(5);
cout << "q的size()为：" << q.size() << endl;
cout << "q的front队头元素为：" << q.front() << endl;
cout << "q的back队尾元素为： " << q.back() << endl;
while (!q.empty())
{
cout << q.front() << endl;
q.pop();
}
}
int main()
{
cout << "testQueue1()当底层实现是容器deque：" << endl;
testQueue1();
cout << endl;
cout << "testQueue2()当底层实现是容器list： " << endl;
testQueue2();
cout << endl;
return 0;
}
四、priority_queue
1.priority_queue的定义
- 优先级队列是一种容器适配器，根据严格的弱排序标准，它的第一个元素总是它所包含的元素中最大的。类似于堆，在堆中可以随时插入元素，并且只能检索最大堆元素（优先级队列中位于顶部的元素）。
- 底层容器可以是任何标准容器类模板，也可以是其他特定设计的容器类。容器应该可以通过随机访问迭代器访问，并支持以下操作：（1）empty()：检测容器是否为空。（2）size()：返回容器中有效元素个数。（3）top()：返回容器中第一个元素的引用（堆顶元素）。（4）push()：在容器尾部插入元素。（5）pop()：删除容器尾部元素。
- 标准容器类vector和deque满足这些需求。如果没有特定的priority_queue类实例化指定容器类，默认情况下使用vector。
- 需要支持随机访问迭代器，以便始终在内部保持堆结构。容器适配器通过在需要时自动调用算法函数make_heap、push_heap和pop_heap来自动完成此操作。
2.priority_queue的使用
#include <iostream>
#include <vector>
#include <queue>
#include <functional>
using namespace std;
void testPriorityQueue1()
{
priority_queue<int> pq;
pq.push(1);
pq.push(5);
pq.push(4);
pq.push(6);
pq.push(3);
pq.push(2);
cout << "pq的size()为：" << pq.size() << endl;
cout << "pq的top()堆顶元素为：" << pq.top() << endl;
while (!pq.empty())
{
cout << pq.top() << endl;
pq.pop();
}
}
void testPriorityQueue2()
{
priority_queue<int, vector<int>, greater<int>> pq;
pq.push(1);
pq.push(5);
pq.push(4);
pq.push(6);
pq.push(3);
pq.push(2);
cout << "pq的size()为：" << pq.size() << endl;
cout << "pq的top()堆顶元素为：" << pq.top() << endl;
while (!pq.empty())
{
cout << pq.top() << endl;
pq.pop();
}
}
int main()
{
cout << "testPriorityQueue1()默认为大的优先级高：" << endl;
testPriorityQueue1();
cout << endl;
cout << "testPriorityQueue2()变为小的优先级高： " << endl;
testPriorityQueue2();
cout << endl;
return 0;
}
3.适配器priority_queue的模拟实现
#include <iostream>
#include <vector>
using namespace std;
namespace sheena
{
template <class T>
struct my_less
{
bool operator()(const T& l, const T& r)
{
return l < r;
}
};
template <class T>
class my_greater
{
public:
bool operator()(const T& l, const T& r)
{
return l > r;
}
};
template <class T, class Container = vector<T>, class Compare = my_less<T>>
class my_priority_queue
{
public:
void adjust_up(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);
adjust_up(_con.size() - 1);
}
void adjust_down(int parent)
{
Compare com;
int 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()
{
swap(_con[0], _con[_con.size() - 1]);
_con.pop_back();
adjust_down(0);
}
T& top()
{
return _con[0];
}
const T& top() const
{
return _con[0];
}
size_t size()
{
return _con.size();
}
bool empty()
{
return _con.empty();
}
private:
Container _con;
};
}
void testPriorityQueue1()
{
sheena::my_priority_queue<int, vector<int>> pq;
pq.push(1);
pq.push(5);
pq.push(4);
pq.push(6);
pq.push(3);
pq.push(2);
cout << "pq的size()为：" << pq.size() << endl;
cout << "pq的top()堆顶元素为：" << pq.top() << endl;
while (!pq.empty())
{
cout << pq.top() << endl;
pq.pop();
}
}
void testPriorityQueue2()
{
sheena::my_priority_queue<int, deque<int>, sheena::my_greater<int>> pq;
pq.push(1);
pq.push(5);
pq.push(4);
pq.push(6);
pq.push(3);
pq.push(2);
cout << "pq的size()为：" << pq.size() << endl;
cout << "pq的top()堆顶元素为：" << pq.top() << endl;
while (!pq.empty())
{
cout << pq.top() << endl;
pq.pop();
}
}
int main()
{
cout << "testPriorityQueue1()默认为大的优先级高：" << endl;
testPriorityQueue1();
cout << endl;
cout << "testPriorityQueue2()变为小的优先级高： " << endl;
testPriorityQueue2();
cout << endl;
return 0;
}
4.仿函数
- 上述例子中my_greater和my_less是一个仿函数。
- 仿函数不是一个函数，是一个类，又称为函数对象，行为像函数一样。既可以是class{};也可以是struct{};，只不过要注意class成员默认访问权限是private，struct成员默认访问权限是public。
- 仿函数可以拥有自己的数据成员和成员变量，在一般函数中是无法实现的。它是一个类，但是行为却和函数一样。它既可以像普通函数一样传入给定数量的参数，还能存储挥着处理更多我们需要的信息。
五、总结
- 为什么选择deque作为stack和queue的底层默认容器？（1）stack和queue不需要遍历（因此stack和queue没有迭代器），只需要在固定的一端或者两端进行操作。（2）在stack中元素增长时，deque比vector的效率高，queue中的元素增长时，deque不仅效率高，而且内存使用率高。
4810
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
