适配器：

虽然 stack 和 queue 中也可以存放元素，但在 STL 中并没有将其划分在容器的行列，而是将其称为 容器适配器 ，这是因为 stack 和队列只是对其他容器的接口进行了包装， STL 中 stack 和 queue 默认使用deque

换种生活上的理解：

我国家用电的电压标准一般是220V，现在大家既然看到这篇博客了，那应该自己也是有一条充电器了。充电器，顾名思义，就是用来给电池充电的设备，它通常包括一个电源适配器和一根充电线。而电源适配器，则是充电器的一个重要组成部分，它的主要功能是将交流电（AC）转换成直流电（DC），并调整电压和电流以满足不同设备的充电需求。 这里电源适配器就是一种适配器，防止了220V的电压与我们接触，保证了我们的人身安全

queue：
priority_queue:

stack与queue：(简单回忆)

栈：一种后进先出的数据结构：(表层的印象理解：)

队列：一种先进先出的数据结构：(表层的印象理解：)

deque的简单介绍：

原理介绍：

deque其实就是vector和list的缝合怪

vector与list的优缺点

vector	list
优点：	优点：
尾插尾删效率不错，支持高效的下标随机访问	按需申请释放空间，不需要扩容
物理空间连续，所以高速缓存利用率高	任意位置插入删除
缺点：	缺点：
空间需要扩容，扩容有一些代价(效率和空间的浪费)	不支持下标随机访问
头部和中间位置插入和删除效率低

看STL_deque原码理解更佳：

总结：

• deque头插尾插效率很高，更甚于vector和list
• deque下标随机访问也还不错，但是相比于vector，vector更胜一筹 
• deque的中间插入删除效率很低

  ---

  这也是为什么STL中stack和queue的适配器是给deque作为缺省值，因为stack和queue的主要实现功能还是出现在头部与尾部，deque在头尾的操作有着比vector和list更加高效的能力，因此，deque作为stack和queue的Cantainer是更适合不过的了，但是在其他情况就该考虑是否vector/list会不会更好呢？

STL中stack的实现：

丰富请参考（点击进入）

功能介绍：

函数声明	接口说明
stack()	构造空的栈
empty()	检测 stack 是否为空
size()	返回 stack 中元素的个数
top()	返回栈顶元素的引用
push()	将元素 val 压入 stack 中
pop()	将 stack 中尾部的元素弹出

底层实现：

#pragma once
#include<iostream>
#include<string>
#include<vector>
#include<list>
#include<deque>
using namespace std;

//template<class T>
//class stack
//{
//private:
//	T* _a;
//	size_t _top;
//	size_t _capacity;
//};

namespace home
{
	template<class T,class Container = deque<T>>
	class stack
	{
	public:
		//Container是一个自定义类型，会自动调用其构造函数，我们无需在此实现
		void push(const T& x)
		{
			_con.push_back(x);
		}
		void pop()
		{
			_con.pop_back();
		}
		const T& top() const
		{
			return _con.back();
		}
		size_t size() const
		{
			return _con.size();
		}
		bool empty() const
		{
			return _con.empty();
		}
	private:
		Container _con;//容器的适配转换出的stack
	};
}

STL中queue的实现：

丰富请参考（点击进入）

功能介绍：

函数声明	接口说明
queue()	构造空的队列
empty()	检测队列是否为空，是返回 true ，否则返回 false
size()	返回队列中有效元素的个数
front()	返回队头元素的引用
back()	返回队尾元素的引用
push()	在队尾将元素 val 入队列
pop()	将队头元素出队列

底层实现：

#pragma once
#include<iostream>
#include<deque>
#include<list>
using namespace std;

namespace home
{
	template<class T, class Container = deque<T>>
	class queue
	{
	public:
		//Container是一个自定义类型，会自动调用其构造函数，我们无需在此实现
		void push(const T& x)
		{
			_con.push_back(x);
		}
		void pop()
		{
			_con.pop_front();
		}
		const T& front() const
		{
			return _con.front();
		}
		const T& back() const
		{
			return _con.back();
		}
		size_t size() const
		{
			return _con.size();
		}
		bool empty() const
		{
			return _con.empty();
		}
	private:
		Container _con;//容器的适配转换出的stack
	};
}

STL中priority_queue的实现：

丰富请参考（点击进入）

功能介绍：

• empty()：检测容器是否为空
• size()：返回容器中有效元素个数
• front()：返回容器中第一个元素的引用
• push_back()：在容器尾部插入元素
• pop_back()：删除容器尾部元素

函数声明	接口说明
priority_queue()/priority_queue(first, last)	构造一个空的优先级队列
empty()	检测优先级队列是否为空，是返回 true ，否则返回 false
top()	返回优先级队列中最大 ( 最小元素 ) ，即堆顶元 素
push(x)	在优先级队列中插入元素 x
pop()	删除优先级队列中最大 ( 最小 ) 元素，即堆顶元 素

在默认情况下priority_queue是大堆，我们可以利用仿函数进行对priority_queue修改成小堆：

仿函数在冒泡排序的使用（参照）（本质一样）：（下面有相关的实现代码）

 

在相关文档中，就体现了仿函数：

 仿函数用于回调，又是一个类，可以使用模板参数 

底层实现：

#pragma once
#include<vector>
//仿函数，本质是一个类，这个类重载operator(),他的对象可以像仿函数一样来使用
template<class T>
class Less
{
public:
	bool operator()(const T& x, const T& y)
	{
		return x < y;
	}
	//仿函数大多是没有成员变量的
};

template<class T>
class Greater
{
public:
	bool operator()(const T& x, const T& y)
	{
		return x > y;
	}

};

//仿函数用于回调，又是一个类，可以使用模板参数
//注意：常常用匿名对象

namespace home
{
	template<class T, class Container = std::vector<T>, class Compare = Less<T>>
	class priority_stack
	{
		//优先级队列其实就是默认按照大堆来top与pop
	public:
		void AdjustUp(int child)//向上调整
		{
			Compare com;
			int parent = (child - 1) / 2;
			while (child > 0)
			{
				//if (_con[parent] < _con[child])
				if (com(_con[parent], _con[child]))
				{
					swap(_con[parent], _con[child]);
					child = parent;
					parent = (child - 1) / 2;
				}
				else
				{
					break;
				}
			}
		}
		void AdjustDown(int parent)//向下调整
		{
			//假设法：先设左孩子小
			size_t child = parent * 2 + 1;
			Compare com;
			while (child < _con.size())//child>=n说明孩子不存在，调整到叶子了
			{
				//孩子的正真调整
				if (child + 1 < _con.size() && com(_con[child], _con[child + 1]))
				{
					++child;
				}
				//if (_con[parent] < _con[child])
				if (com(_con[parent], _con[child]))
				{
					swap(_con[parent], _con[parent]);
					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);
		}

		const T& top()
		{
			return _con[0];
		}

		size_t size() const
		{
			return _con.size();
		}

		bool empty() const
		{
			return _con.empty();
		}
	private:
		Container _con;
	};
}