C++初阶：STL之stack和queue

目录

一.stack

1.1.stack的介绍

1.2.stack的使用

1.3.stack的OJ

题一：最小栈

题二：栈的压入，弹出序列

题三：逆波兰表达式求值(后缀表达式)

题四：用两个栈实现队列

1.4.stack的模拟实现

二.queue

2.1.queue的介绍

2.2.queue的使用

2.3.queue的OJ

题目：用队列实现栈

2.4.queue的模拟实现

三.priority_queue

3.1.priority_queue的介绍

3.2.priority_queue的使用

3.3.priority_queue的OJ

题目：数组中的第K个最大元素

3.4.仿函数

3.5.priority_queue的模拟实现

四.容器适配器

4.1.什么是适配器

4.2.STL标准库中stack和queue的底层结构

4.3.deque的简单介绍(了解)

4.3.1.deque的原理介绍

4.3.2.deque的缺陷

4.4.为什么选择deque作为stack和queue的底层默认容器

4.5.STL标准库中对于stack和queue的模拟实现

4.5.1.stack的模拟实现

4.5.2.queue的模拟实现

---

一.stack

stack是一种后进先出(FIFO)的数据结构。它只有一个出口，形式如下所示。stack允许新增元素，移除元素，取得最顶端元素。但除了最顶端外，没有任何其他方法可以存取stack的其他元素，换言之，stack不允许有遍历行为。将元素推入stack的操作称为push，将元素推出stack的操作称为pop。

1.1.stack的介绍

1.stack是一种容器适配器，专门用在具有后进先出操作的上下文环境中，其只能从容器的一端进行元素的插入与提取操作；
2.stack是作为容器适配器被实现的，容器适配器即是对特定类封装作为其底层的容器，并提供一组特定的成员函数来访问其元素，将特定类作为其底层的，元素特定容器的尾部(即栈顶)被压入和弹出。
3.stack的底层容器可以是任何标准的容器类模板或者一些其他特定的容器类，这些容器类应该支持以下操作：

• empty：判空操作
• back：获取尾部元素操作
• push_back：尾部插入元素操作
• pop_back：尾部删除元素操作

4.标准容器vector、deque、list均符合这些需求，默认情况下，如果没有为stack指定特定的底层容器，默认情况下使用deque。 

注意：

由于stack系以底部容器完成其所有工作，而具有这种"修改某物接口，形成另一种风貌"之性质者，称为adapter(配接器)。因此，STL stack往往不被归类为container(容器)，而被归类为container adapter。

stack所有元素的进出都必须符合“先进后出”的条件，只有stack顶端的元素才有机会被外界取用。stack不提供走访功能，也不提供迭代器。

1.2.stack的使用

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

案例：

#include<iostream>
#include<stack>
using namespace std;

void test_stack()
{
	stack<int> st;
	st.push(1);
	st.push(2);
	st.push(3);
	st.push(4);

	while (!st.empty())
	{
		cout << st.top() << " ";
		st.pop();
	}
	cout << endl;
}

int main()
{
	test_stack();

	return 0;
}

1.3.stack的OJ

题一：最小栈

分析：

设计两个栈：栈_st用于保存栈中的元素，最小栈_minst用于保存栈中元素的最小值。
入栈：若最小栈_minst为空或者当前入栈元素小于等于最小栈_minst的栈顶元素时，则将当前元素入栈(等于的时候也要入栈)，其它情况均不入栈；
出栈：若栈_st出栈的元素和最小栈_minst栈顶的元素相同，则弹出最小栈_minst的栈顶元素。

实现：

class MinStack
{
public:
	//构造
	MinStack()
	{

	}

	//入栈
	void push(int val)
	{
		//只要是压栈，先将元素保存到_st中
		_st.push(val);

		//如果val小于_minst中栈顶的元素，将val再压入_minst中
		if (_minst.empty() || val <= _minst.top())
		{
			_minst.push(val);
		}
	}

	//出栈
	void pop()
	{
		//如果_minst栈顶的元素等于出栈的元素，_minst栈顶的元素要移除
		if (_minst.top() == _st.top())
		{
			_minst.pop();
		}

		_st.pop();
	}

	//取栈顶元素
	int top()
	{
		return _st.top();
	}


	int getMin()
	{
		return _minst.top();
	}
private:
	//保存栈中的元素
	std::stack<int> _st;
	//保存栈中的最小值
	std::stack<int> _minst;

	//struct Data
	//{
	//	int _val;
	//	int _count;
	//};
	保存栈的最小值
	//std::stack<Data> _minst;
};

题二：栈的压入，弹出序列

分析：

1.先把push数组中的值依次进栈st；
2.然后将pop数组中的值依次和栈st里面的值相比较：若相等, 则将pop数组往后移动一位, 并将栈顶元素出栈；若栈顶元素和pop数组中指向的元素不相等或栈为空，则重复第一步；
循环结束条件：push数组走完
是否匹配：如果pop数组也走完了，则匹配；如果pop数组没有走完，则不匹配。

实现：

#include<vector>
class Solution 
{
public:
	bool IsPopOrder(vector<int> pushV, vector<int> popV) 
	{
		//用st来模拟入栈与出栈的过程
		stack<int> st;
		int pushi = 0;
		int popi = 0;
		while (pushi < pushV.size())
		{
			//进栈
			st.push(pushV[pushi++]);

			//如果st不为空且栈顶元素与出栈的元素相等，则出栈
			while (!st.empty() && st.top() == popV[popi])
			{
				st.pop();
				popi++;
			}
		}

		//return popi == popV.size();
		return st.empty();
	}
};

题三：逆波兰表达式求值(后缀表达式)

分析：

1.遇到操作数入栈；
2.遇到操作符，则取栈顶的两个操作数进行运算，并将运算结果重新入栈；
3.最后栈里面的那个值就是结果。
注意：先出栈的是右操作数，后出栈的是左操作数。

实现：

class Solution 
{
public:
	int evalRPN(vector<string>& tokens) 
	{
		stack<int> st;//用于存放运算结果

		//遍历字符串
		for (auto& str : tokens)
		{
			//若遇到操作符
			if (str == "+" || str == "-" || str == "*" || str == "/")
			{
				//取栈顶两个元素
				int right = st.top();
				st.pop();
				int left = st.top();
				st.pop();

				//进行运算
				switch (str[0])
				{
				case '+':
					st.push(left + right);
					break;
				case '-':
					st.push(left - right);
					break;
				case '*':
					st.push(left * right);
					break;
				case '/':
					//题目说明了不存在除数为0的情况
					st.push(left / right);
					break;
				}
			}
			else
			{
				//遇到操作数
				//st.push(stoi(str));
				//C语言的atoi与C++中的stoi函数函数相同，都是将字符串转为整数
				st.push(atoi(str.c_str()));
			}
		}
		//返回最后的结果
		return st.top();
	}
};

拓展：

中缀转后缀：

1. 操作数输出；
2. 操作符：a.若栈为空，进栈；b.若栈不为空，跟栈顶操作符比较，若比栈顶操作符优先级高，则进栈；若比栈顶操作符优先级低或相等，出栈顶操作符输出；遇到( )：1.()优先级最低；2.(不参与比较直接入栈；3.)参与比较直接遇到(。

题四：用两个栈实现队列

实现：

//用两个栈实现队列
class MyQueue 
{
public:
	MyQueue() 
	{

	}

	void push(int x) 
	{
		stackPush.push(x);
	}

	int pop() 
	{
		if (stackPop.empty())
		{
			while (!stackPush.empty())
			{
				stackPop.push(stackPush.top());
				stackPush.pop();
			}
		}

		int tmp = stackPop.top();
		stackPop.pop();
		return tmp;
	}

	int peek() 
	{
		if (stackPop.empty())
		{
			while (!stackPush.empty())
			{
				stackPop.push(stackPush.top());
				stackPush.pop();
			}
		}

		int tmp = stackPop.top();
		return tmp;
	}

	bool empty() 
	{
		return  stackPop.empty() && stackPush.empty();
	}

	stack<int> stackPush;//用于push数据
	stack<int> stackPop;//用于pop数据
};

1.4.stack的模拟实现

从栈的接口中可以看出，栈实际是一种特殊的vector，因此使用vector完全可以模拟实现stack，具体如下：

#include<vector>

namespace bite
{
	template<class T>
	class stack
	{
	public:
		stack()
		{

		}

		void push(const T& x)
		{
			_c.push_back(x);
		}

		void pop()
		{
			_c.pop_back();
		}

		T& top()
		{
			return _c.back();
		}

		const T& top()const
		{
			return _c.back();
		}

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

		bool empty()const
		{
			return _c.empty();
		}
	private:
		std::vector<T> _c;
	};
}

二.queue

queue是一种先进先出(FIFO)的数据结构。它有两个出口，形式如下所示。queue允许新增元素，移除元素，从最底端加入元素，取得最顶端元素。但除了最底端可以加入，最顶端可以取出外，没有任何其他方法可以存取queue的其他元素。换言之，queue不允许有遍历行为。将元素推入queue的操作称为push，将元素推出queue的操作称为pop。

2.1.queue的介绍

1.队列是一种容器适配器，专门用于在FIFO上下文(先进先出)中操作，其中从容器一端插入元素，另一端提取元素；
2.队列作为容器适配器实现，容器适配器即将特定容器类封装作为其底层容器类，queue提供一组特定的成员函数来访问其元素。元素从队尾入队列，从队头出队列；
3.底层容器可以是标准容器类模板之一，也可以是其他专门设计的容器类。该底层容器应至少支持以下操作:

• empty：检测队列是否为空
• size：返回队列中有效元素的个数
• front：返回队头元素的引用
• back：返回队尾元素的引用
• push_back：在队列尾部入队列
• pop_front：在队列头部出队列

4.标准容器类deque和list满足了这些要求。默认情况下，如果没有为queue实例化指定容器类，则使用标准容器deque。

注意：

由于queue系以底部容器完成其所有工作，而具有这种"修改某物接口，形成另一种风貌"之性质者，称为adapter(配接器)，因此，STL queue往往不被归类为container(容器)，而被归类为container adapter。

queue所有元素的进出都必须符合“先进先出”的条件，只有queue顶端的元素，才有机会被外界取用，queue不提供遍历功能，也不提供迭代器。

2.2.queue的使用

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

案例：

#include<iostream>
#include<queue>
using namespace std;

void test_queue()
{
	queue<int> q;
	q.push(1);
	q.push(2);
	q.push(3);
		
	while(!q.empty())
	{
		//queue与stack相同的是入数据都是push,但出数据stack是top,queue是front
		cout << q.front() << " ";
		q.pop();
	}
	cout << endl;
}

int main()
{
	test_queue();

	return 0;
}

2.3.queue的OJ

题目：用队列实现栈

分析：

入数据：往不为空的队列入数据；
出数据：假设有一个队列不为空，然后判断该队列是否真的不为空，否则另一个队列不为空；接着将不为空的队列里的数据导入到空队列，直到不为空的队列只剩下一个数据，最后将这个数据pop出。

实现：

class MyStack 
{
public:
    MyStack() 
    {

    }

    void push(int x) 
    {
        //往不为空的队列中插入元素
        if (!q1.empty())
        {
            q1.push(x);
        }
        else
        {
            q2.push(x);
        }
    }

    int pop() 
    {
        //emptyQ指向空队列，并假设q1队列为空
        queue<int>* emptyQ = &q1;
        queue<int>* noemptyQ = &q2;
        if (!q1.empty())
        {
            //交换两个指针
            swap(emptyQ, noemptyQ);
        }

        //把不为空的队列中的元素导入到空队列，直到只剩下一个元素
        while (noemptyQ->size() > 1)
        {
            emptyQ->push(noemptyQ->front());
            noemptyQ->pop();
        }

        //返回不为空的队列中仅剩的一个元素
        int tmp = noemptyQ->front();
        noemptyQ->pop();

        return tmp;
    }

    int top()
    {
        //哪个队列不为空，就返回哪个队列中的队尾元素
        if (!q1.empty())
            return  q1.back();
        else
            return q2.back();
    }

    bool empty() 
    {
        //两个队列都为空才是空
        return q1.empty() && q2.empty();
    }

    queue<int> q1;
    queue<int> q2;
};

2.4.queue的模拟实现

因为queue的接口中存在头删和尾插，因此使用vector来封装效率太低，故可以借助list来模拟实现queue，具体如下：

#include <list>

namespace bite
{
	template<class T>
	class queue
	{
	public:
		queue() 
		{

		}

		void push(const T& x) 
		{ 
			_c.push_back(x);
		}

		void pop() 
		{ 
			_c.pop_front(); 
		}

		T& back() 
		{ 
			return _c.back();
		}

		const T& back()const 
		{ 
			return _c.back(); 
		}

		T& front() 
		{
			return _c.front();
		}

		const T& front()const 
		{
			return _c.front();
		}

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

		bool empty()const 
		{ 
			return _c.empty(); 
		}

	private:
		std::list<T> _c;
	};
}

三.priority_queue

顾名思义，priority_queue是一个拥有权值观念的queue，它允许加入新元素，移除旧元素，审视元素值等功能。由于这是一个queue，所以只允许在底端加入元素，并从顶端取出元素，除此之外别无其他存取元素的途径。

priority_queue带有权值观念，其内的元素并非依照被推入的次序排列，而是自动依照元素的权值排列(通常权值以实值表示)。权值最高者，排在最前面。

缺省情况下priority_queue系利用一个max-heap完成，后者是一个以vector表现的complete binary tree。max-heap可以满足priority_queue所需要的“依权值高低自动递归排序”的特性。

3.1.priority_queue的介绍

1.优先队列是一种容器适配器，根据严格的弱排序标准，它的第一个元素总是它所包含的元素中最大的。
2.此上下文类似于堆，在堆中可以随时插入元素，并且只能检索最大堆元素(优先队列中位于顶部的元素)。
3.优先队列被实现为容器适配器，容器适配器即将特定容器类封装作为其底层容器类，queue提供一组特定的成员函数来访问其元素。元素从特定容器的“尾部”弹出，其称为优先队列的顶部。
4.底层容器可以是任何标准容器类模板，也可以是其他特定设计的容器类。容器应该可以通过随机访问迭代器访问，并支持以下操作：

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

5.标准容器类vector和deque满足这些需求。默认情况下，如果没有为特定的priority_queue类实例化指定容器类，则使用vector。
6.需要支持随机访问迭代器，以便始终在内部保持堆结构。容器适配器通过在需要时自动调用算法函数make_heap、push_heap和pop_heap来自动完成此操作。

注意：

queue以底部容器完成其所有工作。具有这种"修改某物接口，形成另一种风貌"之性质者，称为adapter(配接器)，因此，STL priority_queue往往不被归类为container(容器)，而被归类为container adapter。

priority_queue的所有元素，进出都有一定的规则，只有queue顶端的元素(权值最高者)，才有机会被外界取用，priority_queue不提供遍历功能，也不提供迭代器。

3.2.priority_queue的使用

template < class T, class Container = vector<T>,
           class Compare = less<typename Container::value_type> > class priority_queue;

优先级队列默认使用vector作为其底层存储数据的容器，在vector上又使用了堆算法将vector中元素构造成堆的结构，因此priority_queue就是堆，所有需要用到堆的位置，都可以考虑使用priority_queue。

注意：

默认情况下priority_queue是大根堆，其对应的仿函数默认是less。如果想要实现成小根堆，则需要自己传入仿函数greater，对应的头文件为functional.h。

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

 案例一：

默认情况下，priority_queue是大堆。

#include<queue>
#include<functional>//greater算法的头文件

void test_priority_queue()
{
	//仿函数/函数对象
	//默认是大堆：大的优先级高
	//priority_queue<int> pq;

	//小堆，小的优先级高
	//如果要创建小堆，将第三个模板参数换成greater比较方式
	priority_queue<int, vector<int>, greater<int>> pq;
	pq.push(1);
	pq.push(0);
	pq.push(5);
	pq.push(2);
	pq.push(1);
	pq.push(7);

	while (!pq.empty())
	{
		cout << pq.top() << " ";
		pq.pop();
	}
	cout << endl;
}

int main()
{
	test_priority_queue();
	return 0;
}

案例二：

如果在priority_queue中放自定义类型的数据，用户需要在自定义类型中提供>或者<的重载。

class Date
{
public:
	Date(int year = 1900, int month = 1, int day = 1)
		: _year(year)
		, _month(month)
		, _day(day)
	{

	}

	bool operator<(const Date& d) const
	{
		return (_year < d._year) ||
			(_year == d._year && _month < d._month) ||
			(_year == d._year && _month == d._month && _day < d._day);
	}

	bool operator>(const Date& d) const
	{
		return (_year > d._year) ||
			(_year == d._year && _month > d._month) ||
			(_year == d._year && _month == d._month && _day > d._day);
	}

	friend ostream& operator<<(ostream& _cout, const Date& d)
	{
		_cout << d._year << "-" << d._month << "-" << d._day;
		return _cout;
	}

private:
	int _year;
	int _month;
	int _day;
};

void TestPriorityQueue()
{
	//如果要创建大堆，需要用户在自定义类型中提供<的重载
	priority_queue<Date> q1;
	q1.push(Date(2018, 10, 29));
	q1.push(Date(2018, 10, 28));
	q1.push(Date(2018, 10, 30));
	cout << q1.top() << endl;

	//如果要创建小堆，需要用户在自定义类型中提供>的重载
	priority_queue<Date, vector<Date>, greater<Date>> q2;
	q2.push(Date(2018, 10, 29));
	q2.push(Date(2018, 10, 28));
	q2.push(Date(2018, 10, 30));
	cout << q2.top() << endl;
}

3.3.priority_queue的OJ

题目：数组中的第K个最大元素

分析：

法一：先调用<algorithm>中的sort函数对数组进行排升序，然后得到数组中第k个最大元素，也就是数组中下标为nums.size() - k的元素。sort的底层原理是快排，时间复杂度为：O(N*logN)。

法二：先将数组中前k个元素进行小堆的建立，然后将剩下它元素依次和堆顶元素进行比较，只要比堆顶元素大，就pop()出堆顶元素，并将这个元素push()进堆，最后堆顶的元素就是第k个最大的元素。时间复杂度为：O(K + (N - K) * logK)，空间复杂度是 O(K)。

法三：先用priority_queue将数组建成一个大堆，然后将队列中前k-1个元素pop()掉，最后再top()一次就是数组中第k个最大的元素。时间复杂度为：O(N + K * logN)，空间复杂度为：O(N)。

实现：

class Solution
{
public:
	int findKthLargest(vector<int>& nums, int k)
	{
		//法一：
		//底层是快排，时间复杂度为：O(N*logN)
		sort(nums.begin(), nums.end());
		return nums[nums.size() - k];

		//法二：
		//小堆
		//时间复杂度为：O(K)
		priority_queue<int, vector<int>, greater<int>> pq(nums.begin(), nums.begin() + k);
		//时间复杂度为：O(N-K)*logK
		for (size_t i = k; i < nums.size(); ++i)
		{
			if (nums[i] > pq.top())
			{
				pq.pop();
				pq.push(nums[i]);
			}
		}
		return pq.top();
		//整体时间复杂度：O((N-K)logK+K)

		//法三：
		//将数组中的元素先放入优先级队列中，时间复杂度为O(N)
		priority_queue<int> pq(nums.begin(), nums.end());
		//将优先级队列中前k-1个元素删除掉，时间复杂度：O(KlogN)
		while (--k)
		{
			pq.pop();
		}
		return pq.top();
	}
	//整体时间复杂度：O(KlogN+N)
};

3.4.仿函数

仿函数(functor)，就是使一个类的使用看上去像一个函数。其实现就是类中实现一个operator()，这个类就有了类似函数的行为，就是一个仿函数类了。

有时仿函数的使用是为了函数拥有类的性质，以达到安全传递函数指针，依据函数生成对象，甚至是让函数之间有继承关系，对函数进行运算和操作的效果。比如set就使用了仿函数less ，而less继承的binary_function，就可以看作是对于一类函数的总体声明了，这是函数做不到的。

案例：

//普通函数
bool LessFun(int x, int y)
{
	return x < y;
}

//仿函数
//仿函数(functor)，就是使一个类的使用看上去像一个函数。其实现就是类中实现一个operator()，这个类就有了类似函数的行为，就是一个仿函数类了
//仿函数实质是个对象
struct Less
{
	bool operator()(int x, int y)
	{
		return x < y;
	}
};

int main()
{
	//普通函数
	cout << LessFun(1, 2) << endl;

	//仿函数
	Less ls;
	cout << ls(2, 3) << endl;
	//ls(2, 3) ==> ls.operator()(2, 3)
	//cout << ls.operator()(2, 3) << endl;

	return 0;
}

我们往往将仿函数实现成模板类，这样比较任意不同类型，如下所示：

//仿函数写成模板类，这样比较任意不同类型
//写成struct更好，因为struct的默认权限是公有public的
template<class T>
struct Less
{
	bool operator()(const T& x, const T& y)
	{
		return x < y;
	}
};

int main()
{
	Less<int> less1;
	cout << less1(1, 2) << endl;

	Less<int> less2;
	cout << less2(3.1, 4.2) << endl;

	return 0;
}

3.5.priority_queue的模拟实现

由于priority_queue完全以底部容器为根据，再加上heap处理规则，所以其实现非常简单。缺省情况下是以vector为底部容器。

#pragma once

#include<iostream>
#include<functional>
#include<vector>

using namespace std;

namespace bite
{
	//仿函数
	template<class T>
	struct less
	{
		bool operator()(const T& x, const T& y)
		{
			return x < y;
		}
	};

	//仿函数
	template<class T>
	struct greater
	{
		bool operator()(const T& x, const T& y)
		{
			return x > y;
		}
	};

	//大堆
	template<class T, class Container = vector<T>, class Compare = less<T>>
	class priority_queue
	{
	public:
		//向上调整
		void adjust_up(int child)
		{
			Compare com;//元素大小比较标准

			int parent = (child - 1) / 2;
			while (child > 0)
			{
				//if (_con[child] > _con[parent])
				//if ((Compare()(_con[parent], _con[child]))//采用匿名对象
				if (com(_con[parent], _con[child]))
				{
					swap(_con[child], _con[parent]);
					child = parent;
					parent = (child - 1) / 2;
				}
				else
				{
					break;
				}
			}
		}

		//向下调整
		void adjust_down(int parent)
		{
			size_t child = parent * 2 + 1;
			while (child < _con.size())
			{
				Compare com;//元素大小比较标准

				//找以parent为根的较大的孩子
				//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;
				}
			}
		}

		//先插入一个元素到容器尾部，然后再调用向上调整算法，直到满足堆的性质
		void push(const T& x)
		{
			//先插入
			_con.push_back(x);
			//后向上调整
			adjust_up(_con.size() - 1);
		}

		//先将堆顶元素与容器尾部的元素进行交换，然后删除容器尾部的元素，也就是删除原来的堆顶元素，最后再从堆顶开始，进行向下调整，直到满足堆的性质
		void pop()
		{
			//判空
			if (empty())
				return;

			//交换第一个和最后一个元素
			swap(_con[0], _con[_con.size() - 1]);
			//删除栈顶元素
			_con.pop_back();
			//向下调整
			adjust_down(0);
		}

		//堆顶元素不允许修改，因为堆顶元素修改会破坏堆的特性
		const T& top() const
		{
			return _con[0];
		}

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

		bool empty() const
		{
			return _con.empty();
		}

	private:
		Container _con;//底层容器
	};


	void test_priority_queue1()
	{
		//仿函数/函数对象
		//默认是大堆：大的优先级高
		priority_queue<int> pq;
		//priority_queue<int,deque<int>> pq;

		//小堆，小的优先级高
		//如果要创建小堆，将第三个模板参数换成greater比较方式
		//priority_queue<int, vector<int>, greater<int>> pq;

		pq.push(1);
		pq.push(0);
		pq.push(5);
		pq.push(2);
		pq.push(1);
		pq.push(7);

		while (!pq.empty())
		{
			cout << pq.top() << " ";
			pq.pop();
		}
		cout << endl;
	}


	//如果在priority_queue中存放自定义类型的数据，用户需要在自定义类型中提供>或者<的运算符重载
	class Date
	{
	public:
		Date(int year = 1900, int month = 1, int day = 1)
			: _year(year)
			, _month(month)
			, _day(day)
		{

		}

		bool operator<(const Date& d) const
		{
			return (_year < d._year) ||
				(_year == d._year && _month < d._month) ||
				(_year == d._year && _month == d._month && _day < d._day);
		}

		bool operator>(const Date& d) const
		{
			return (_year > d._year) ||
				(_year == d._year && _month > d._month) ||
				(_year == d._year && _month == d._month && _day > d._day);
		}

		friend ostream& operator<<(ostream& _cout, const Date& d)
		{
			_cout << d._year << "-" << d._month << "-" << d._day;
			return _cout;
		}

	private:
		int _year;
		int _month;
		int _day;
	};

	//仿函数
	class PDataLess
	{
	public:
		bool operator()(const Date* p1, const Date* p2)
		{
			return *p1 < *p2;
		}
	};

	//仿函数
	class PDataGreater
	{
	public:
		bool operator()(const Date* p1, const Date* p2)
		{
			return *p1 > *p2;
		}
	};

	void test_priority_queue2()
	{
		//如果要创建小堆，需要用户在自定义类型中提供<的重载
		//q1中存放的是自定义类型的数据，所以需要重载<<运算符
		priority_queue<Date> q1;
		q1.push(Date(2018, 10, 29));
		q1.push(Date(2018, 10, 28));
		q1.push(Date(2018, 10, 30));
		cout << q1.top() << endl;

		//如果要创建小堆，需要用户在自定义类型中提供>的重载
		//q1中存放的是自定义类型的数据，所以需要重载<<运算符
		priority_queue<Date, vector<Date>, greater<Date>> q2;
		q2.push(Date(2018, 10, 29));
		q2.push(Date(2018, 10, 28));
		q2.push(Date(2018, 10, 30));
		cout << q2.top() << endl;

		//如果存放的是日期类指针，如果再采取上面的方式是取不出来的，因为它里面存放的是地址，
		//所以我们需要手动实现一个仿函数对其进行解引用再进行比较
		priority_queue<Date*, vector<Date*>, PDataLess> q3;
		q3.push(new Date(2018, 10, 29));
		q3.push(new Date(2018, 10, 28));
		q3.push(new Date(2018, 10, 30));
		cout << *(q3.top()) << endl;
	}
}

四.容器适配器

4.1.什么是适配器

适配器是一种设计模式(设计模式是一套被反复使用的、多数人知晓的、经过分类编目的、代码设计经验的总结)，该种模式是将一个类的接口转换成客户希望的另外一个接口。

4.2.STL标准库中stack和queue的底层结构

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

4.3.deque的简单介绍(了解)

vector是单向开口的连续线性空间，deque则是一种双向开口的连续线性空间，所谓双向开口，意思是可以在头尾两端分别做元素的插入和删除操作，如图所示。

4.3.1.deque的原理介绍

deque(双端队列)：是一种双开口的"连续"空间的数据结构，双开口的含义是：可以在头尾两端进行插入和删除操作，且时间复杂度为O(1)。与vector比较，头插效率高，不需要搬移元素；与list比较，空间利用率比较高。

deque的中控器

deque并不是真正连续的空间，而是由一段段连续的小空间拼接而成的，实际deque类似于一个动态的二维数组。

deque采用一块所谓的map(注意：不是STL的map容器)作为主控，这里所谓map是一块连续空间，其中每个元素(此处称为一个节点node)都是指针，指向另一段(较大的)连续线性空间，称为缓冲区，缓冲区才是deque的存储空间主题。SGI STL允许我们指定缓冲区大小，默认值0表示将拥有512bytes缓冲区。map其实是一个T**，也就是说它是一个指针，所指之物又是一个指针，指向型别为T的一块空间。其底层结构如下图所示：

deque的迭代器

deque的最大任务，便是在这些分段的定量连续空间上，维护其整体连续的假象，并提供随机存取的接口。避开了“重新配置，复制，释放”的轮回，代价则是复杂的迭代器架构。

deque是分段连续空间。维持其“整体连续”的假象的任务，落在了迭代器的operator++和operator--两个运算符身上。

deque迭代器应该具备什么结构？首先，它必须能够指出分段连续空间(亦即缓冲区)在哪里；其次，它必须能够判断自己是否已经处于其所在缓冲区的边缘，如果是，一旦前进或后退时就必须跳跃至下一个或上一个缓冲区。为了能够正确跳跃，deque必须随时掌握管控中心map。deque的中控器，缓冲区，迭代器的相互关系如下所示：

那deque是如何借助其迭代器维护其假想连续的结构呢？deque中存在两个名为start和finish的迭代器，deque::begin()传回迭代器start，deque::end()传回迭代器finish，如下图所示。迭代器start内的cur指针指向缓冲区的第一个元素，迭代器finish内的cur指针指向缓冲区的最后元素(的下一个位置)。注意，最后一个缓冲区尚有备用空间，稍后若有新元素要插入于尾端，可直接拿此备用空间来使用。

4.3.2.deque的缺陷

与vector比较，deque的优势是：其头部插入和删除时，不需要搬移元素，效率特别高，而且在扩容时，也不需要搬移大量的元素，因此其效率是必vector高的。与list比较，其底层是连续空间，空间利用率比较高，不需要存储额外字段。
但是，deque有一个致命缺陷：不适合遍历，因为在遍历时，deque的迭代器要频繁的去检测其是否移动到某段小空间的边界，导致效率低下，而序列式场景中，可能需要经常遍历，因此在实际中，需要线性结构时，大多数情况下优先考虑vector和list，deque的应用并不多，而目前能看到的一个应用就是，STL用其作为stack和queue的底层数据结构。

4.4.为什么选择deque作为stack和queue的底层默认容器

stack是一种后进先出的特殊线性数据结构，因此只要具有push_back()和pop_back()操作的线性结构，都可以作为stack的底层容器，比如vector和list都可以；queue是先进先出的特殊线性数据结构，只要具有push_back()和pop_front()操作的线性结构，都可以作为queue的底层容器，比如list。但是STL中对stack和queue默认选择deque作为其底层容器，主要是因为：

1. stack和queue不需要遍历(因此stack和queue没有迭代器)，只需要在固定的一端或者两端进行操作；
2. 在stack中元素增长时，deque比vector的效率高(扩容时不需要搬移大量数据)；queue中的元素增长时，deque不仅效率高，而且内存使用率高。

结合了deque的优点，而完美的避开了其缺陷。 

4.5.STL标准库中对于stack和queue的模拟实现

4.5.1.stack的模拟实现

#include<vector>
#include<list>
#include<deque>
#include<iostream>

using namespace std;

namespace bite
{
	template<class T, class Con = deque<T>>
	//template<class T, class Con = vector<T>>
	//template<class T, class Con = list<T>>
	class stack
	{
	public:
		stack() 
		{

		}

		void push(const T& x) 
		{ 
			_c.push_back(x); 
		}

		void pop() 
		{
			_c.pop_back();
		}

		T& top() 
		{ 
			return _c.back(); 
		}

		const T& top() const 
		{ 
			return _c.back(); 
		}

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

		bool empty() const 
		{ 
			return _c.empty(); 
		}
	private:
		Con _c;
	};
}

4.5.2.queue的模拟实现

#include<vector>
#include<list>
#include<deque>
#include<iostream>

using namespace std;

namespace bite
{
	template<class T, class Con = deque<T>>
	//template<class T, class Con = list<T>>
	class queue
	{
	public:
		queue() 
		{

		}

		void push(const T& x) 
		{ 
			_c.push_back(x); 
		}

		void pop()
		{ 
			_c.pop_front();
		}

		T& back() 
		{
			return _c.back();
		}

		const T& back() const 
		{ 
			return _c.back(); 
		}

		T& front() 
		{ 
			return _c.front();
		}

		const T& front() const 
		{ 
			return _c.front(); 
		}

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

		bool empty() const 
		{
			return _c.empty(); 
		}
	private:
		Con _c;
	};
}