目录
stack介绍
stack的使用
stack的模拟实现
queue的介绍
queue的使用
queue的模拟实现
deque
priority_queue
priority_queue的使用
仿函数
priority_queue的模拟实现
stack介绍：
stack是一种容器适配器，专门用在具有后进先出操作的上下文环境中，其删除只能从容器的一端进行元素的插入与提取操作。
stack的使用：
| stack() | 构造空的栈 |
| empty() | 检测stack是否为空 |
| size() | 返回stack中元素个数 |
| top() | 返回栈顶元素的引用 |
| push() | 将元素val压入栈中 |
| pop() | 将stack中尾部的元素弹出 |
stack的模拟实现：
//适配器模式
namespace qwe
{
//stack<int, vector<int>> s;
//stack<int, list<int>> s;
template<class T, class Container = deque<T>>
class stack
{
public:
bool empty() const
{
return _con.empty();
}
size_t size() const
{
return _con.size();
}
const T& top() const
{
return _con.back();
}
void push(const T& x)
{
_con.push_back(x);
}
void pop()
{
_con.pop_back();
}
private:
//vector<T> _v;
Container _con;
};
void test_stack()
{
//后进先出--不支持迭代器
stack<int> s;
s.push(1);
s.push(2);
s.push(3);
s.push(400);
while (!s.empty())
{
cout << s.top() << " ";
s.pop();
}
cout << endl;
}
}queue的介绍：
队列是一种容器适配器，专门用于在FIFO上下文(先进先出)中操作，其中从容器一端插入元素，另一端提取元素。
queue的使用：
| queue() | 构造空的队列 |
| empty() | 检测队列是否为空 |
| size() | 返回队列中元素个数 |
| front() | 返回队头元素的引用 |
| back() | 返回队尾元素的引用 |
| push() | 在队尾将元素val入队列 |
| pop() | 将队头的元素出队列 |
queue的模拟实现：
namespace qwe
{
template<class T, class Container = deque<T>>
class queue
{
public:
bool empty() const
{
return _con.empty();
}
size_t size() const
{
return _con.size();
}
const T& front() const
{
return _con.front();
}
const T& back() const
{
return _con.back();
}
void push(const T& x)
{
_con.push_back(x);
}
void pop()
{
_con.pop_front();
}
private:
Container _con;
};
void test_queue()
{
//queue<int, vector<int>> q;
//queue<int, list<int>> q;
queue<int> q;
q.push(10);
q.push(20);
q.push(30);
q.push(40);
while (!q.empty())
{
cout << q.front() << " ";
q.pop();
}
cout << endl;
}
}deque：
双端队列，融合vector和list优点。
vector优点：下标随机访问，尾插尾删效率高，cup高速缓存命中高。
vector缺点：扩容(效率、空间浪费)、不适合头插头删。
list优点：按需申请释放空间，任意位置O(1)插入删除。
list缺点：不支持随机访问。
deque：适合头尾的插入删除
如果stack用vector默认适配：
deque优势：扩容代价不大，不需要拷贝数据，浪费空间不多。
如果stack用list默认适配：
deque优势：cpu高速cache命中。不会频繁申请小块空间。申请和释放空间次数少代价低。
如果queue用list默认适配：
deque优势：cpu高速cache命中。不会频繁申请小块空间。申请和释放空间次数少代价低。
priority_queue:
优先队列是一种容器适配器，根据严格的弱排序标准，它的第一个元素总是它所包含的元素中最大的。
priority_queue的使用：
| priority_queue() / priority_queue(first,last) | 构造 |
| empty() | 检测是否为空 |
| top() |
返回优先级队列中最大(最小元素)，即堆顶元素
|
| push(x) |
在优先级队列中插入元素x
|
| pop() |
删除优先级队列中最大(最小)元素，即堆顶元素
|
默认情况下priority_queue是大堆
如果在priority_queue中放自定义类型的数据，用户需要在自定义类型中提供> 或者< 的重载。
仿函数：
struct Less
{
bool operator()(int x, int y)
{
return x < y;
}
};
struct Greater
{
bool operator()(int x, int y)
{
return x > y;
}
};
int main()
{
// Less->仿函数类型 less就叫函数对象
Less less;
cout << less(1, 2) << endl;
Greater gt;
cout << gt.operator()(1, 2) << endl;
cout << gt(1, 2) << endl;
Less<int> lessi;
cout << lessi(1, 2) << endl;
cout << Less<int>()(1, 2) << endl;
cout << Less<double>()(1.1, 2.2) << endl;
return 0;
}priority_queue的模拟实现：
namespace qwe
{
template<class T>
struct Less
{
bool operator()(const T& x, const T& y) const
{
return x < y;
}
};
//特化
template<>
struct Less<Date*>
{
bool operator()(Date* x, Date* 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
{
private:
void adjust_up(size_t child)
{
Compare com;
size_t parent = (child - 1) / 2;
while (child > 0)
{
//if (_con[child] > _con[parent])
if (com(_con[parent], _con[child]))
{
swap(_con[child], _con[parent]);
child = parent;
parent = (child - 1) / 2;
}
else
{
break;
}
}
}
void adjust_down(size_t parent)
{
Compare com;
size_t child = (parent * 2) + 1;
while (child < _con.size())
{
//if (child + 1 < _con.size() && _con[child + 1] > _con[child])
if (child + 1 < _con.size() && com(_con[child], _con[child + 1]))
{
++child;
}
//if (_con[child] > _con[parent])
if (com(_con[parent], _con[child]))
{
swap(_con[child], _con[parent]);
parent = child;
child = parent * 2 + 1;
}
else
{
break;
}
}
}
public:
priority_queue()
{}
template<class InputIterator>
priority_queue(InputIterator first, InputIterator last)
:_con(first, last)
{
//建堆
for (int i = (_con.size() - 1 - 1) / 2; i >= 0; --i)
{
adjust_down(i);
}
}
void push(const T& x)
{
_con.push_back(x);
adjust_up(_con.size() - 1);
}
void pop()
{
swap(_con[0], _con[_con.size() - 1]);
_con.pop_back();
adjust_down(0);
}
const T& top()
{
return _con[0];
}
size_t size()
{
return _con.size();
}
bool empty()
{
return _con.empty();
}
private:
Container _con;
};
void test_priority_queue()
{
// 默认是大的优先级高 -- 默认给的仿函数是less
//priority_queue<int> pq;
// 控制小的优先级高 -- 给一个greater的仿函数
//priority_queue<int, deque<int>, Greater<int>> pq;
priority_queue<int, deque<int>, greater<int>> pq;
pq.push(3);
pq.push(3);
pq.push(7);
pq.push(1);
pq.push(9);
while (!pq.empty())
{
cout << pq.top() << " ";
pq.pop();
}
cout << endl;
}
}
