【C++】stack和queue

---

前言（重点）

在学习栈和队列之前，我们先要了解一个东西，这个东西对我们学习本节内容很重要。我们现在只是浅浅的了解一下，等stack和queue都模拟实现完了，我们再来仔细讲

这个deque就是我们常说的容器适配器。那么，什么是容器适配器呢？
这就要牵扯出另外的知识了——设计模式（这个设计模式C++并没有Java那么关注）

很早之前，设计模式一共有23种。到目前为止，种类在一步步的扩展
我们这里的适配器就是设计模式的一种——适配器模式；而除了我们这里的适配器以外，我们前面还学过一种设计模式——迭代器模式。这个迭代器也是一种设计模式

这里我们只要记住适配器模式和迭代器模式的作用：

迭代器模式：不暴露底层细节，封装过后，提供统一的方式来访问容器
适配器模式：用已有的东西，封装转换出想要的东西
我们要记住这两个结论，下面会用到

我们只需要知道迭代器和适配器都是一种设计模式就行了，有兴趣可以深入了解一下

---

一、stack

1、 stack的介绍

stack文档
接下来对stack的文档进行简单的总结一下：

1. stack是一种容器适配器，专门用在具有后进先出操作的上下文环境中，其删除只能从容器的一端进行元素的插入与提取操作。

2. stack是作为容器适配器被实现的，容器适配器即是对特定类封装作为其底层的容器，并提供一组特定的成员函数来访问其元素，将特定类作为其底层的，元素特定容器的尾部(即栈顶)被压入和弹出。

3. stack的底层容器可以是任何标准的容器类模板或者一些其他特定的容器类，这些容器类应该支持以下操作：

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

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

我们前面数据结构学习了栈和队列，所以本节内容的栈和队列使用方面的知识就不多讲了，和前面数据结构的思路是一样的

2、queue的使用

函数接口	函数接口的作用
stack（）	构建空的栈
empty（）	判断stack是否为空
size（）	返回stack中的元素个数
top（）	返回stack中的栈顶元素
push（）	向stack中压入指定数据
pop（）	弹出stack尾部的数据

其实可以看到，有了前面的基础这里就很容易理解，接口一看就知道是干什么的，有什么作用

3、stack的模拟实现

大家是不是认为我们模拟实现要像以前一样，stack是通过数组实现的，所以要malloc开辟，然后还要一个top数据、一个capacity、一个size…
其实这里就不用这么麻烦，我们可以更加简单的实现，就是基于容器适配器的功劳

#include 
namespace bzh
{
    
    template<class T, class Container = vector<T>>//这里就是运用了适配器
    //本来我们是要重新写一个stack的，但是因为适配器的原因，我们直接通过vector转换出来了我们想要的stack
    //template>//这里使用deque也是可以的，具体为什么可以我们后面讲
    class stack
    {
    public:
        stack()
        {}
        void push(const T& x)
        {
            _Con.push_back(x);
        }
        void pop()
        {
            _Con.pop_back();
        }
        T& top()
        {
            return _Con.back();
        }
        const T& top()const
        {
            return _Con.back();
        }
        size_t size()const
        {
            return _Con.size();
        }
        bool empty()const
        {
            return _Con.empty();
        }
    private:
        Container _Con;
    };
};

可以看到，接口实现的作用是正确的，而我们模板传参的参数就是vector类型

看得出来很简单，那么我们就快速的也把queue搞定，进入我们的容器适配器内容

---

二、queue

1、queue的介绍

queue文档

进行总结一下：

1. 队列是一种容器适配器，专门用于在FIFO上下文(先进先出)中操作，其中从容器一端插入元素，另一端提取元素。

2. 队列作为容器适配器实现，容器适配器即将特定容器类封装作为其底层容器类，queue提供一组特定的成员函数来访问其元素。元素从队尾入队列，从队头出队列。

3. 底层容器可以是标准容器类模板之一，也可以是其他专门设计的容器类。该底层容器应至少支持以下操作:

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

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

可以看到内容与我们前面数据结构的queue相差无几。而且这里也提到了容器适配器

2、queue的使用

函数接口	函数接口的作用
queue（）	构建空的队列
empty（）	判断队列是否为空
size（）	返回队列中的元素个数
front（）	返回队头素的引用
back（）	返回队尾素的引用
push（）	在队尾插入指定数据
pop（）	讲队头元素出队列

这些接口对于我们来说也是简简单单，那么我们就直接上手模拟实现

3、queue的模拟实现

与stack一样，这里使用了容器适配器

#pragma once
#include 
#include 
namespace bzh
{
    //template>//这里使用deque也是可以的
    template<class T, class Container = list<T>>
    //这里就是通过容器适配器讲list转换成我们想要的queue了
    class queue
    {
    public:
        queue()
        {}
        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& front()
        {
            return _Con.front();
        }
        const T& front()const
        {
            return _Con.front();
        }
        size_t size()const
        {
            return _Con.size();
        }
        bool empty()const
        {
            return _Con.empty();
        }
    private:
        Container _Con;
    };
};

那么经过上面的栈和队列的学习之后，我们对于容器适配器的

迭代器模式：不暴露底层细节，封装过后，提供统一的方式来访问容器
适配器模式：用已有的东西，封装转换出想要的东西

这两句话有了更进一步的理解

我们现在就来进行一下小结：

三、容器适配器

1、什么是容器适配器呢？

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

类似于上图

2、STL标准库中stack和queue的底层结构

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


那么，也就得出来了，上面为什么模拟实现stack和queue的时候，采用deque也可以了，这就是因为STL中，栈和队列的底层就是deque

现在我们就来了解什么是deque

四、deque

我们指定vector和list各有优缺点：

vector：1、头部中部插入删除效率低；2、要扩容
list：1、不支持随机访问；2、cpu高速缓存命中率低

那么，有没有一种完美的容器，将两者的优点结合，缺点抹除了呢？
答案是有的。就是deque。但是，既然你是将vector和list相结合，并且抹除了两者的缺点，那么就导致了deque缺点少，但是优点不明显

1、deque的原理介绍

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

注意：这里的deque和queue完全是两个东西，deque并没有队列的“先进先出”的特定，不要混淆。
我们使用deque的场景是比较少的。在下面的小结我会提出上面场景使用deque合适

deque并不是真正连续的空间，而是由一段段连续的小空间拼接而成的，实际deque类似于一个动态的二维数组，其底层结构如下图所示：

双端队列底层是一段假象的连续空间，实际是分段连续的，为了维护其“整体连续”以及随机访问的假象，落在了deque的迭代器身上，因此deque的迭代器设计就比较复杂，如下图所示：

小问题：那deque是如何借助其迭代器维护其假想连续的结构呢？

2、deque的使用

deque是采用多个buffer数组+中控数组（指针数组）组成的

buffer数组里面存放这我们的数据，而中控数组里面存放的是指针，这些指针都指向一个buffer数组。我们第一次插入数据的时候，开辟一个buffer数组，然后中控数组的指针（第一次指向开辟数组的指针并不是在中控数组的开始位置，而是在中间位置，这是为了头插更方便）指向该buffer数组，一直在该数组进行尾插，等到数组满了，就进行扩容，开辟第二个buffer数组，然后由上一个指针在中控数组的下一个位置的指针指向新开辟的buffer数组，尾插以此类推
头插数据在开辟号buffer数组之后，就通过第一次中控数组出现的指针前一个位置，的指针指向

deque随机访问下标：

我们的buffer数组大小是固定的，所以我们可以先用下标/buffer数组大小，找到我们要访问的数据在第几个buffer数组里面；再通过下标%buffer数组大小，算出来我们要访问的数据，位于改buffer数组中的第几个位置

可以看出来deque的下标随机访问是很麻烦的，而且还没有vector快。这也就是我们说的，deuqe没有了vector和list的缺点，但是它的优点不突出

3、deque的缺陷

与vector比较，deque的优势是：

头部插入和删除时，不需要搬移元素，效率特别高，而且在扩容时，也不需要搬移大量的元素，因此其效率是必vector高的

与list比较：

其底层是连续空间，空间利用率比较高，不需要存储额外字段

但是，deque有一个致命缺陷：

不适合遍历，因为在遍历时，deque的迭代器要频繁的去检测其是否移动到某段小空间的边界，导致效率低下，而序列式场景中，可能需要经常遍历，因此在实际中，需要线性结构时，大多数情况下优先考虑vector和list，deque的应用并不多，而目前能看到的一个应用就是，STL用其作为stack和queue的底层数据结构

小结

所以，在一下场景有利于我们使用deque：

1、中部插入删除操作少，头尾删除插入操作多
2、偶尔进行下标随机访问

5、为何选择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的优点，而完美的避开了其缺陷

---

五、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来自动完成此操作。

1、priority_queue的使用

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

函数声明	作用
priority_queue()/priority_queue(frist,last)	创建空的优先级队列
empty（）	判断优先级队列是否为空
top（）	返回优先级队列最大/最小的数据，也就是堆顶数据
push（val)	在优先级队列插入val
pop（）	删除优先级队列最大/最小的数据，也就是堆顶数据

这些接口现在来看就是小儿科了

2、priority_queue的模拟实现

#pragma once
namespace bzh
{
	template<class T, class Contianor = vector<T>>
	class priority_queue
	{
	public:
		void adjust_up(int child)//向上调整
		{
			while (child > 0)
			{
				int person = (child - 1) / 2;
				if (_con[person] < _con[child])
				{
					swap(_con[person], _con[child]);
					child = person;
					person = (child - 1) / 2;
				}
				else
				{
					break;
				}
			}
		}
		void adjust_down(int person)//向下调整
		{
			int child = person * 2 + 1;
			if (child + 1 < _con.size() && _con[child] < _con[child + 1])
			{
				child++;
			}
			while (child < _con.size())
			{
				if (_con[person] < _con[child])
				{
					swap(_con[person], _con[child]);
					person = child;
					child = person * 2 + 1;
				}
				else
				{
					break;
				}
			}
		}
		priority_queue()//默认构造函数
		{}
		template<class Tua>
		priority_queue(Tua first, Tua last)//这里相当于传参的构造函数，所以我们要写一个无参的默认构造函数
			:_con(first, last)
		{
			for (size_t i = (_con.size() - 1 - 1) / 2; i >= 0; --i)
			{
				adjust_down(i);
			}
		}

		void push(const T& val)
		{
			_con.push_back(val);
			adjust_up(_con.size() - 1);
		}
		void pop()
		{
			swap(_con[0], _con[_con.size() - 1]);
			_con.pop_back();
			adjust_down(0);
		}
		const T& top()const
		{
			return _con[0];
		}
		bool empty()const
		{
			return _con.empty();
		}
		size_t size()const
		{
			return _con.size();
		}
	private:
		Contianor _con;
	};
};

---

六、仿函数

仿函数的本质是一个类，它重载了一个运算符——（），使用时的函数名就是operator（）

举例：
比较大小的两个仿函数

namespace abcd
{
	template <class T>
	class less
	{
	public:
		bool operator()(const T& num1, const T& num2)
		{
			return num1 < num2;
		}
	};
	template <class T>
	class greater
	{
	public:
		bool operator()(const T& num1, const T& num2)
		{
			return num1 > num2;
		}
	};
}

样例

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(new Date(2018, 10, 29));
	q2.push(new Date(2018, 10, 28));
	q2.push(new Date(2018, 10, 30));
	cout << *q2.top() << endl;
	priority_queue<Date*, vector<Date*>, less<Date*>> 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;
}

我们自己写一个比较仿函数

class Less
{
public:
	bool operator()(const Date* num1, const Date* num2)
	{
		return *num1 < *num2;
	}
};
class Greater
{
public:
	bool operator()(const Date* num1, const Date* num2)
	{
		return *num1 > *num2;
	}
};

七、反向迭代器

我们前面也接触了反向迭代器，正向迭代器++是向后面走；而反向迭代器++是往前面走

下面是反向迭代器的实现代码：

#pragma once
template<class Iterator, class Ref, class Ptr>
class ReverseIterator
{
public:
	//T,T&,T*
	//const T,const T&,const T*
	typedef ReverseIterator<Iterator, Ref, Ptr> self;
	ReverseIterator(Iterator s)
		:it(s)
	{}
	Ptr operator->()//返回数据的地址
	{
		return &(operator*());
	}
	Ref operator*()//返回数据
	{
		Iterator tmp = it;
		return *(--tmp);
	}
	self& operator++()
	{
		--it;
		return *this;
	}
	self& operator--()
	{
		++it;
		return *this;
	}

	bool operator==(const self& s)const
	{
		return it == s.it;
	}
	bool operator!=(const self& s)const
	{
		return !operator==(s);
	}
private:
	Iterator it;
};

我们可以在list和vector里面引入头文件，然后实现反向迭代器：

		typedef ReverseIterator<iterator, T&, T*> reverse_iterator;
		typedef ReverseIterator<const_iterator, const T&, const T*> const_reverse_iterator;
		reverse_iterator rbegin()
		{
			return reverse_iterator(end());
		}
		reverse_iterator rend()
		{
			return reverse_iterator(begin());
		}