目录
一、栈的模拟和deque容器
1.deque
1.1deque结构
1.2deque优缺点
2.stack模拟
二、队列的模拟
三、priority_queue优先级队列
1.优先级队列模拟
2.添加仿函数
一、栈的模拟和deque容器
在之前，我们学过了C语言版本的栈，可以看这篇文章 栈和队列。
但是C语言没有模板，我们只能固定一个类型去写，在C++中引入了模板的概念，我们只需要写一份，在调用中给到类型，编译器会自动去帮我们推导是栈里面元素的类型，会非常方便。
1.deque
我们可以看到，库函数里面的栈调用的是一个deque容器。
deque(双端队列)：是一种双开口的"连续"空间的数据结构，双开口的含义是：可以在头尾两端进行插入和删除操作，且时间复杂度为O(1)，与vector比较，头插效率高，不需要搬移元素；与list比较，空间利用率比较高。
1.1deque结构
首先deque有一个中控数组，这个数据是指针数组，存放的内容是指针，每个指针都指向的一块空间的起始地址。
他的迭代器有 cur（当前数据当前位置） fisrt（数据起始位置）last（数据结尾位置） node（指向数据的指针）。
头插就去找到最前面的那个有效指针进行头插，尾插就找最后面那个有效指针尾插，遍历就通过迭代器每一个空间块从头遍历到位，就换下一个空间块。
1.2deque优缺点
deque实际上是一个缝合怪，他结合了vector和list的内容，将他们糅合在了一起。
优点
与vector比较，deque的优势是 ：头部插入和删除时，不需要搬移元素，效率特别高，而且在扩容时，也不需要搬移大量的元素，因此其效率是必vector高的。
与list比较，其底层是连续空间，空间利用率比较高，不需要存储额外字段。
但是他也有缺点
deque容器不适合遍历，因为在遍历时，deque的迭代器要频繁的去检测其是否移动到某段小空间的边界，导致效率低下，而序列式场景中，可能需要经常遍历，因此在实际中，需要线性结构时，大多数情况下优先考虑vector和list。
那么为何他能在栈和队列中使用，并成为默认容器呢？
因为栈和队列需要尾插，尾删，队列需要尾插，头删deque容器完全可以适配这些需求，因为不需要遍历，并且deque扩容时不需要挪动数据，这也是的deque的效率变高。
2.stack模拟
stack的模拟非常简单，调用模板Container容器的函数就可以了，也不需要迭代器（不用遍历），也不需要构造函数析构函数什么的，因为Container容器是自定义类型，会自动调用的相关构造析构拷贝函数。
#pragma once
#include<deque>
namespace kky
{
template<class T, class Container = deque<T>>
class stack
{
public:
void push(const T& x)
{
_con.push_back(x);
}
void pop()
{
_con.pop_back();
}
const T& top()
{
return _con.back();
}
bool empty()
{
return _con.empty();
}
size_t size()
{
return _con.size();
}
private:
Container _con;
};
}二、队列的模拟
队列模拟跟stack差不都，多了一个back接口，出数据的时候要调用pop_front()
#pragma once
#include<deque>
namespace kky
{
template<class T, class Container = deque<T>>
class queue
{
public:
void push(const T& x)
{
_con.push_back(x);
}
void pop()
{
_con.pop_front();
}
const T& front()
{
return _con.front();
}
const T& back()
{
return _con.back();
}
bool empty()
{
return _con.empty();
}
size_t size()
{
return _con.size();
}
private:
Container _con;
};
}三、priority_queue优先级队列
优先级队列出数据的时候，会先出优先级高的数据。
如何来判断优先级的高低呢？
这跟你传的数据类型有关，先举个例子
我们插入了 1,10,8,5,6 但出数据的时候缺省按照数据的大小顺序来出的，在这里使用数据的大小来看段他们优先级的高低。
优先级队列出数据时会帮我们做好排序，他的本质就是堆，通过堆的向上向下调整来处理优先级问题。具体堆排序的过程可以看选择排序中的堆排序。
1.优先级队列模拟
优先级队列的模拟实现就是要建堆，每一次插入数据都要进行向上调整，保证是大堆或者小堆。
出数据的时候将第一个数据和最后一个数据互换，再进行尾删，因为第一个数据是我们想要出的数据，将他和最后一个数据交换再尾删，就可以提取出这个数据了，同时现在只有第一个元素不符合小堆或者大堆的情况，其他元素都符合，因此进行一次从索引为0位置的向下调整即可。
namespace kky
{
template<class T,class Container = vector<T>>
class priority_queue
{
public:
void adjust_up(size_t child)
{
while(child>0)
{
size_t parent = (child - 1) / 2;
if (_con[child] > _con[parent])
{
swap(_con[child], _con[parent]);
child = parent;
}
else
{
break;
}
}
}
void adjust_down(size_t parent)
{
int child = parent * 2 + 1;
while (child < _con.size())
{
if (child + 1 < _con.size() && _con[child] < _con[child + 1])
{
child++;
}
if (_con[child] > _con[parent])
{
swap(_con[child], _con[parent]);
parent = child;
child = parent * 2 + 1;
}
else
{
break;
}
}
}
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);
}
T& top()
{
return _con[0];
}
bool empty()
{
return _con.empty();
}
size_t size()
{
return _con.size();
}
private:
Container _con;
};
}刚刚的代码构建了一个大堆，但是我们如果想要构建小堆，难不成又要重写一份代码吗？ 那必定不是可能的。
2.添加仿函数
在C语言中，我们可以通过函数指针来处理顺序的问题，但是函数指针类型很繁琐，并且不容易理解，C++推出了仿函数来帮助我们处理这类问题。
写一个类，仅仅重载了operator()，返回类型为bool，在后面进行判断的时候，我们就可以调用这个类对象的()，类似于函数一样，就可以处理了，
template<class T>
class Less
{
public:
bool operator()(const T& x1, const T& x2)
{
return x1 < x2;
}
};第一个方式太丑陋了，一般使用第二种方式去调用。
那之前，我们代码中的判断语句，都可以通过调用仿函数更改了
给模板参数再添加一个类
template<class T, class Container = vector<T>,class Compare = Less<T>>现在就可以开始更改了
只需要注意顺序即可，需要这样判断的都可以更改，参考如下代码
namespace kky
{
template<class T, class Container = vector<T>,class Compare = Less<T>>
class priority_queue
{
public:
void adjust_up(size_t child)
{
Compare com;
while (child > 0)
{
size_t parent = (child - 1) / 2;
if (com(_con[parent], _con[child]))
{
swap(_con[child], _con[parent]);
child = parent;
}
else
{
break;
}
}
}
void adjust_down(size_t 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 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);
}
T& top()
{
return _con[0];
}
bool empty()
{
return _con.empty();
}
size_t size()
{
return _con.size();
}
private:
Container _con;
};
}这是我们写的Less仿函数，如果你想让优先级队列建小堆，就可以写再写一个仿函数
template<class T>
class Greater
{
public:
bool operator()(const T& x1, const T& x2)
{
return x1 > x2;
}
};需要的时候调用一下即可
