目录
1.什么是适配器？
2.栈(stack)
3.队列(queue)
4.双端队列(deque)
5.优先级队列(priority_queue)
1.什么是仿函数？
2.仿函数有什么用？
3.优先级队列(priority_queue)
1.什么是适配器？
我们之前实现栈和队列，都是我们自己去实现相应的功能，那么今天我们可以使用容器适配器来实现我们的栈和队列，那么什么是适配器呢？
我们日常生活中所见到的电源充电器，就是一种适配器，当我们使用的时候，会跟我们的插座相匹配，从而供我们使用。
2.栈(stack)
那么在栈和队列的实现中，我们该怎样使用相应的容器适配器呢？我们都知道，栈是一种后进先出的结构，它在一定程度上和我们的vector很相似，那么有什么办法可以用vector来模拟出一个栈呢？答案是可以的：
template<class T, class Container = vector<T>>
class stack
{
public:
void push(const T& x)
{
_con.push_back(x);
}
void pop()
{
_con.pop_back();
}
T& top()
{
return _con[_con.size() - 1];
}
const T& top()const
{
return _con[_con.size() - 1];
}
bool empty()const
{
return _con.empty();
}
size_t size()const
{
return _con.size();
}
private:
Container _con;
};这里在模板参数中，我们多了一个Container的模板参数，它的默认模板为vector模板，因为我们学习过vector和stack的使用， 因此用vector模拟一个stack还是非常简单的，本质上都是vector的调用，只不过我们在使用栈的时候，底层是vector而已。
3.队列(queue)
对于队列来说，我们要实现的是先进先出的结构，此时我们发现，vector是模拟实现不了queue的，所以我们想到了list：
template<class T, class Container = list<T>>
class queue
{
public:
void push(const T& x)
{
_con.push_back(x);
}
void pop()
{
_con.pop_front();
}
T& back()
{
return _con.back();
}
const T& back()const
{
return _con.back();
}
T& top()
{
return _con.front();
}
const T& top()const
{
return _con.front();
}
bool empty()const
{
return _con.empty();
}
size_t size()const
{
return _con.size();
}
private:
Container _con;
};这里的使用还是调用的list的功能，对于queue来说先进先出即可，我们看起来使用的是queue，实际上是用list来模拟的。
4.双端队列(deque)
双端队列从名字就能看出来，它好像前后都可以快速插入和删除。实际上确实如此，双端队列类似vector和list的结合体，取精华去糟粕，它的底层是用指针数组来存储一小段连续的空间，但每个小段又是不连续的，因此它整体的空间其实是不连续的。相比于vector 和 list，deque的两端插入和删除效率都是不错的，但是其在中间插入的效率却很低。
它的使用与vector 和 list类似，这里我们看一下就知道该如何使用了，这里提到双端队列想要说的是，我们在模拟栈和队列的时候，可以把Container 默认都改为deque，因为栈和队列不涉及在中间段插入删除数据，只有在一端插入和删除，因此使用deque效率更优。
5.优先级队列(priority_queue)
优先级队列在插入和删除过程中需要满足一个优先级，优先级大的数据将被优先服务，这也就意味着当我们在插入和删除数据时，并不时按照队列那样先进先出的概念。
priority_queue的基础模拟实现：
template<class T, class Container = vector<int>, class Compare = less<T>>
class priority_queue
{
public:
private:
Container _con;
Compare com;
};这里我们看到，我们的模板参数多了一个Compare = less<T> ，这是什么东西呢？那么我们就先来了解一下仿函数的概念：
1.什么是仿函数？
template<class T>
class less
{
public:
bool operator()(const T& v1, const T& v2)
{
return v1 < v2;
}
};
template<class T>
class greater
{
public:
bool operator()(const T& v1, const T& v2)
{
return v1 > v2;
}
};仿函数本质上是一个类，它的使用就像是一个函数，它的里面必须要有operator() (括号)的重载，以上两个less 和 greater就是两个仿函数，里面有着判断数据大小的功能，也就是重载了() operator() 。
2.仿函数有什么用？
我们在使用库里面的sort函数的时候默认是升序，此时就可以使用仿函数来改变为降序：
这里就是仿函数的使用，它可以改变我们的比较方式，从而改变我们的排序是升序还是降序，来达到我们的使用要求。
3.优先级队列(priority_queue)
那么再来回头看看我们的优先级队列，我们已经说过，优先级队列在插入和删除的时候要遵循优先级大的先被服务，因此就少不了仿函数来随时的改变数据的优先级。
template<class T, class Container = vector<int>, class Compare = less<T>>
class priority_queue
{
public:
template <class InputIterator>
priority_queue(InputIterator first, InputIterator last)
{
while (first != last)
{
_con.push_back(*first);
first++;
AdjustUp(_con.size() - 1);
}
}
void AdjustUp(size_t child)
{
size_t 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 AdjustDown(int parent)
{
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[parent], _con[child]);
parent = child;
child = parent * 2 + 1;
}
else
break;
}
}
void push(const T& x)
{
_con.push_back(x);
AdjustUp(_con.size() - 1);
}
void pop()
{
swap(_con[0], _con[_con.size() - 1]);
_con.pop_back();
AdjustDown(0);
}
T& top()
{
return _con[0];
}
const T& top()const
{
return _con[0];
}
bool empty()
{
return _con.empty();
}
size_t size()
{
return _con.size();
}
private:
Container _con;
Compare com;
};我们这里的优先级队列实质上是用vector容器来模拟了堆的实现，在push和pop(插入和删除)的时候使用了向上调整和向下调整，并且两种调整函数中的比较逻辑使用了仿函数，方便我们在使用的过程中修改优先级比较逻辑。
以上就是C++中栈、队列的基础知识，如有错误欢迎批评指正！
