C++【栈&队列(3种)&反向迭代器】

一、容器适配器

适配器是一种设计模式(设计模式是一套被反复使用的、多数人知晓的、经过分类编目的、代码设计经验的总结)，该种模式是将一个类的接口转换成客户希望的另外一个接口。
后面所介绍的栈，队列，反向迭代器都是一种适配器。
虽然stack和queue中也可以存放元素，但在STL中并没有将其划分在容器的行列，而是将其称为容器适配器，这是因为stack和队列只是对其他容器的接口进行了包装，STL中stack和queue底层实现默认使用的是deque。deque双端队列。如下图：

二、栈

（一）栈定义

stack是一种容器适配器，专门用在具有后进先出操作的上下文环境中，其删除只能从容器的一端进行元素的插入与提取操作。stack是作为容器适配器被实现的，容器适配器即是对特定类封装作为其底层的容器，并提供一组特定的成员函数来访问其元素，将特定类作为其底层的，元素特定容器的尾部(即栈顶)被压入和弹出。stack的底层容器可以是任何标准的容器类模板或者一些其他特定的容器类，这些容器类应该支持以下操作：
empty：判空操作
back：获取尾部元素操作
push_back：尾部插入元素操作
pop_back：尾部删除元素操作
标准容器vector、deque、list均符合这些需求，默认情况下，如果没有为stack指定特定的底层容器，默认情况下使用deque。

（二）栈使用接口

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

（三）栈模拟实现

这里我这里栈的底层容器是用vector实现的。

(1) 栈模拟实现解析

#pragma once

namespace nza
{
	template<class T, class Container=vector<int>>
	class stack
	{
	public:
		void push(const T& x)
		{
			_co.push_back(x);
		}
		void pop()
		{
			_co.pop_back();
		}
		const T& top()
		{
			return _co.back();
		}
		size_t size()
		{
			return _co.size();
		}
		bool empty()
		{
			return _co.empty();
		}
	private:
		Container _co;
	};
}

先把模板里面模板类容器deque换成vector，在stack类里面的私有域，进行实例化对象，因为栈只能在一端进行操作，就得有插入和删除栈顶元素，对应的就是尾插和尾删，直接调用vector尾插和尾删接口即可，取栈顶就直接调用vector的取队尾接口，大小和判空也是直接调用vector的接口。

(2) 栈模拟实现代码

#pragma once

namespace nza
{
	template<class T, class Container=vector<int>>
	class stack
	{
	public:
		void push(const T& x)
		{
			_co.push_back(x);
		}
		void pop()
		{
			_co.pop_back();
		}
		const T& top()
		{
			return _co.back();
		}
		size_t size()
		{
			return _co.size();
		}
		bool empty()
		{
			return _co.empty();
		}
	private:
		Container _co;
	};
}

#include"simulate_stack.h"
#include<iostream>
#include<vector>
#include<list>
using namespace std;

void test1()
{
	nza::stack<int> s;
	s.push(6);
	s.push(1);
	s.push(8);
	s.push(3);
	s.push(7);
	while (!s.empty())
	{
		cout << s.top() << " ";
		s.pop();
	}
	cout << endl;
}
int main()
{
	test1();
}

(3) 栈模拟结果

三、队列

（一）普通队列

（1）普通队列定义

队列是一种容器适配器，专门用于在FIFO上下文先进先出中操作，其中从容器一端插入元素，另一端提取元素。 队列作为容器适配器实现，容器适配器即将特定容器类封装作为其底层容器类，queue提供一组特定的成员函数来访问其元素。元素从队尾入队列，从队头出队列。底层容器可以是标准容器类模板之一，也可以是其他专门设计的容器类。该底层容器应至少支持以下操作:
empty：检测队列是否为空
size：返回队列中有效元素的个数
front：返回队头元素的引用
back：返回队尾元素的引用
push_back：在队列尾部入队列
pop_front：在队列头部出队列
标准容器类deque和list满足了这些要求。默认情况下，如果没有为queue实例化指定容器类，则使用标准容器deque。

（2）队列使用接口

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

（3）普通队列模拟实现

（1）普通队列模拟实现解析

#pragma once

namespace nza
{
	template<class T, class Container = list<int>>
	class queue
	{
	public:
		void push(const T& x)
		{
			_co.push_back(x);
		}
		void pop()
		{
			_co.pop_front();
		}
		const T& front()
		{
			return _co.front();
		}
		const T& back()
		{
			return _co.back();
		}
		size_t size()
		{
			return _co.size();
		}
		bool empty()
		{
			return _co.empty();
		}
	private:
		Container _co;
	};
}

同样，这里的队列也是先把模板里面模板类容器deque换成vector，在queue类里面的私有域，进行实例化对象，因为栈队列是先进先出，就得有插入和删除头部元素，对应的就是尾插和头删，直接调用vector尾插和头删接口即可，取队头和取队尾就直接调用vector的取头接口和取尾接口，大小和判空也是直接调用vector的接口。

（2）普通队列模拟实现代码

#pragma once

namespace nza
{
	template<class T, class Container = list<int>>
	class queue
	{
	public:
		void push(const T& x)
		{
			_co.push_back(x);
		}
		void pop()
		{
			_co.pop_front();
		}
		const T& front()
		{
			return _co.front();
		}
		const T& back()
		{
			return _co.back();
		}
		size_t size()
		{
			return _co.size();
		}
		bool empty()
		{
			return _co.empty();
		}
	private:
		Container _co;
	};
}

#include"simulate_queue.h"
#include<iostream>
#include<vector>
#include<list>

using namespace std;

void test1()
{
	nza::queue<int> s;
	s.push(9);
	s.push(7);
	s.push(5);
	s.push(3);
	while (!s.empty())
	{
		cout << s.front() << " ";
		s.pop();
	}
	cout << endl;

}
int main()
{
	test1();
}

（3）普通队列模拟结果

（二）优先级队列

（1）优先级队列定义

优先队列也是一种容器适配器，根据严格的弱排序标准，它的第一个元素总是它所包含的元素中最大的。此上下文类似于堆，在堆中可以随时插入元素，并且只能检索最大堆元素(优先队列中位于顶部的元素)。优先队列被实现为容器适配器，容器适配器即将特定容器类封装作为其底层容器类，queue提供一组特定的成员函数来访问其元素。元素从特定容器的“尾部”弹出，其称为优先队列的顶部。 底层容器可以是任何标准容器类模板，也可以是其他特定设计的容器类。容器应该可以通过随机访问迭代器访问，并支持以下操作：
empty()：检测容器是否为空
size()：返回容器中有效元素个数
front()：返回容器中第一个元素的引用
push_back()：在容器尾部插入元素
标准容器类vector和deque满足这些需求。默认情况下，如果没有为特定的priority_queue类实例化指定容器类，则使用vector。 需要支持随机访问迭代器，以便始终在内部保持堆结构。容器适配器通过在需要时自动调用算法函数make_heap、push_heap和pop_heap来自动完成此操作。

（2）优先级队列接口

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

（3）优先级队列模拟实现

（1）优先级队列模拟实现解析

#pragma once
namespace nza
{
	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 AjustDown(size_t parent)
		{
			compare comp;
			size_t child = 2 * parent + 1;
			while (child<_con.size())
			{
				if (child + 1 < _con.size() && comp(_con[child] ,_con[child + 1]))
				{
					++child;
				}
				if (comp(_con[parent], _con[child]))
				{
					swap(_con[child], _con[parent]);
					parent = child;
					child = 2 * parent + 1;
				}
				else
				{
					break;
				}
			}
		}
		void AjustUp(int child)
		{
			compare comp;
			int parent = (child-1)/ 2;
			while (child>0)
			{
				if (comp(_con[parent], _con[child]))
				{
					swap(_con[child], _con[parent]);
					child = parent;
					parent = (child - 1) / 2;
				}
				else
				{
					break;
				}

			}
		}
			
		void push_back(const T& x)
		{
			_con.push_back(x);
			AjustUp(_con.size() - 1);

		}
		void pop_back()
		{
			swap(_con[0], _con[_con.size() - 1]);
			_con.pop_back();
			AjustDown(0);

		}
		const T& top()
		{
			return _con[0];
		}
		size_t size()
		{
			return _con.size();
		}
		bool empty()
		{
			return _con.empty();
		}
	private:
		container _con;
	};
}

less和greater是一种仿函数，less建的是大根堆最后排序的结果是从大到小，greater建的是小根堆最后排序的结果是从小到大。
1 .仿函数：是定义了一个含有operator()成员函数的对象，可以视为一个一般的函数，只不过这个函数功能是在一个类中的运算符operator()中实现，是一个函数对象，它将函数作为参数传递的方式来使用，这里要用到其中的两个优点：仿函数比函数指针的执行速度快，函数指针时通过地址调用，而仿函数是对运算符operator进行重载来提高调用的效率和仿函数可以作为模板参数使用，因为每个仿函数都拥有自己的类型。

比如这里的Compare com实例化对一个对象，Compare这里控制比较方式，传greater，_con就是greater的对象，它去调用operator()就是大于的比较方式。

上面的Compare是一个泛型，如果你传的是less，就和greater没关系了，com就是一个less对象。传什么就用什么，我是一个less对象就调用的就是less的oparator。模板传的是类型，仿函数是一个类，就可以用模板参数传，整个类都可以用，如果是函数参数传，某个地方传某个函数用。它可以做到整个类传过来，整个可以用。

2.插入：，在尾巴进行插入，再进行向上调整，从_con.size() - 1最后一个位置向上调整，这时我们就要写一个向上调整算法。
向上调整算法：
我这里实现的是小根堆，向上调整的算法思路是从孩子结点开始，从下到上比较孩子结点和父亲结点的大小，如果比父亲小，就交换父子结点，并更新孩子结点，即让孩子结点到父亲的位置，并求出此时父亲的大小，继续比较，直到孩子结点为0停止，也就是到根了；反之如果比父亲结点大就停止循环，不用调整。

3.删除：不能直接挪动数据会导致时间复杂度增大，应该是先把第一个和最后一个进行交换，再把尾部的数据删除，最后向下调整，这时还要写一个向下调整算法。
向下调整算法：
从根节点即父亲结点开始，和他两个孩子结点最大的比较，从上到下调整。我先假设左孩子child就是最大，之后再来个if函数进行比较，如果child + 1 < n，确保有右孩子，并且child+1如果小于child，说明左孩子小，就++。之后如果最小的孩子比父亲节点小，那就调整，并更新父亲结点，让父亲到孩子结点的位置，并求出它下一个孩子结点下标，如果大于就停止。
4.取堆顶元素：也就是直接返回0号下标对应的数据。
5.大小和盘判空：大小和判空也是直接调用vector的接口。

（2）优先级队列模拟实现接口

#pragma once
namespace nza
{
	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 AjustDown(size_t parent)
		{
			compare comp;
			size_t child = 2 * parent + 1;
			while (child<_con.size())
			{
				if (child + 1 < _con.size() && comp(_con[child] ,_con[child + 1]))
				{
					++child;
				}
				if (comp(_con[parent], _con[child]))
				{
					swap(_con[child], _con[parent]);
					parent = child;
					child = 2 * parent + 1;
				}
				else
				{
					break;
				}
			}
		}
		void AjustUp(int child)
		{
			compare comp;
			int parent = (child-1)/ 2;
			while (child>0)
			{
				if (comp(_con[parent], _con[child]))
				{
					swap(_con[child], _con[parent]);
					child = parent;
					parent = (child - 1) / 2;
				}
				else
				{
					break;
				}

			}
		}
			
		void push_back(const T& x)
		{
			_con.push_back(x);
			AjustUp(_con.size() - 1);

		}
		void pop_back()
		{
			swap(_con[0], _con[_con.size() - 1]);
			_con.pop_back();
			AjustDown(0);

		}
		const T& top()
		{
			return _con[0];
		}
		size_t size()
		{
			return _con.size();
		}
		bool empty()
		{
			return _con.empty();
		}
	private:
		container _con;
	};
}

#include"Simulate_PriorityQueue.h"
#include<iostream>
#include<vector>
using namespace std;
void test()
{
	nza::priority_queue<int, vector<int>,nza::greater<int>> q;
	/*nza::priority_queue<int> q;*/
	q.push_back(8);
	q.push_back(4);
	q.push_back(2);
	q.push_back(9);
	q.push_back(6);
	q.push_back(1);
	while (!q.empty())
	{
		cout << q.top() << " ";
		q.pop_back();
	}
	cout << endl;
}
int main()
{
	test();
	return 0;

}

（3）优先级队列模拟结果

（三）双端队列

介绍：
deque是双端队列，是一种双开口的"连续"空间的数据结构，双开口的含义是：可以在头尾两端进行插入和删除操作，且时间复杂度为O(1)，与vector比较，头插效率高，不需要搬移元素；与list比较，空间利用率比较高。deque并不是真正连续的空间，而是由一段段连续的小空间拼接而成的，实际deque类似于一个动态的二维数组。

结构特点：
双端队列实际上是一个中控器，实际是一个指针数组，插入是从中间进行插入的。中控满了就扩容，但是扩容代价低。它的底层是一段假象的连续空间，实际是分段连续的，为了维护其“整体连续”以及随机访问的假象，落在了deque的迭代器身上，因此deque的迭代器设计就比较复杂。里面封装了四个指针，第一个是cur指向当前数据的位置，第二个是finish指向缓冲区的首位置，第三个是last指向缓冲区的末位置，第四个是node指向中控器上的缓冲区指针。

优点：
相比vector，扩容代价低，头插头删，尾插尾删效率高，也支持随机访问。

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

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

四、反向迭代器

（1）反向迭代器实现思路和解析

反向迭代器 是一种反向遍历容器的迭代器，是普通迭代器的适配器，通过重新定义自增和自减操作，以达到按反序遍历元素的目的。

#pragma once
namespace nza
{
	template<class iterator, class re, class p>
	struct Reverseiterator
	{
		typedef Reverseiterator<iterator,re, p> self;
		iterator _cur;
		Reverseiterator(iterator it)
			:_cur(it)
		{}
		re operator*()
		{
			iterator tmp(_cur);
			--tmp;
			return *tmp;
		}
		self&  operator++()
		{
			--_cur;
			return *this;
		}
		self& operator--()
		{
			++_cur;
			return *this;

		}
		bool operator!=(const self& s)
		{
			return _cur!= s._cur;

		}
	};
}

实现思路：
正常思路是把原先list实现的正向迭代器改成reverse，然后其他类函数做相应的修改。
但是这样做只能实现我们当前实现的容器的反向迭代器，如果再换vector容器就不行了，因为它的正向迭代器就是内置类型，不能直接拷贝cv直接改，除非它不用原生指针，像list一样去封装迭代器。前面在开头说反向迭代器是一种适配器，现在我们要让这个反向迭代器不仅适配vector，而且也适配list，达到真正的复用。

如上的代码参考了stl源码里面高手写的代码的思想，主要摆脱冗余重复问题，变的更加泛型即更广泛地适配各类容器。
这里的思想就是用正向迭代器封装反向迭代器，就不用关心我们的正向迭代器是原生的还是封装的，这样实现一个反向迭代器，所有容器的反向迭代器都出来了，前提是双向迭代器，支持减减。传list的正向，就适配list的反向，传vector的正向，适配vector的反向，后面还有deque等，一劳永逸地去解决问题，当我们思考还停留在实现list的反向迭代器的时候，高手的思考是要解决有容器的反向迭代器。
函数解析：
1、模板第一个参数是任意类型的迭代器，第二个参数re是迭代器中返回值类型，第三个参数是重载箭头符号的返回值类型，再用正向迭代器实例化一个对象_cur。初始化构造函数就用正向迭代器初始化_cur。
2、它的解引用没有取当前位置，它是前一个位置，因为原先的rend是在哨兵位上，rbegin在末尾，这时候的rend在哨兵位下一个恶结点，rbegin在哨兵位结点上，当然这是list，vector也一样只不过它是数组没有头结点，所以在遍历的时候要想从最后位置开始就需要先减减。这里为了能顺利遍历下一位数据，需要先拷贝一份临时变量再减减，又因为临时变量具有常性，所以要有引用返回(这里没有用的是re，因为在容器类实现里面已经传了如图2)。如上设计特点其实就是为了追求一个对称,如下图1：

3、同样反向迭代器支持移动，实现反向迭代器的++就是- -，实现- -就是++，也支持比较。

（2）反向迭代器实现代码(以vector为例)

#pragma once
namespace nza
{
	template<class iterator, class re, class p>
	struct Reverseiterator
	{
		typedef Reverseiterator<iterator,re, p> self;
		iterator _cur;
		Reverseiterator(iterator it)
			:_cur(it)
		{}
		re operator*()
		{
			iterator tmp(_cur);
			--tmp;
			return *tmp;
		}
		self&  operator++()
		{
			--_cur;
			return *this;
		}
		self& operator--()
		{
			++_cur;
			return *this;

		}
		bool operator!=(const self& s)
		{
			return _cur!= s._cur;

		}
	};
}

# pragma once
#include<assert.h>
#include<algorithm>
//#include<vector>
#include<string>
#include"ReverseIterator.h"
namespace nza
{

     template<class T>
	 class vector
	 {
	 public:
		 typedef T* iterator;
		 typedef const T* const_iterator;

		 typedef Reverseiterator<iterator, T&,const T*> reverse_iterator;
		 typedef Reverseiterator<iterator, const T&, const T* > const_reverse_iterator;

		 vector()//构造函数
		 {}
		 ~vector()
		 {
			 delete[] _start;
			 _start = _finish = _end_capacity = nullptr;
		 }
		 iterator begin()
		 {
			 return _start;
		 }
		 iterator end()
		 {
			 return _finish;

		 }
		 reverse_iterator rbegin()
		 {
			 return  reverse_iterator(end());
		 }
		 reverse_iterator rend()
		 {
			 return  reverse_iterator(begin());
		 }
		 const_iterator begin() const
		 {
			 return _start;

		 }
		 const_iterator end() const
		 {
			 return _finish;
		 }
		size_t size() const
		 {
			 return _finish - _start;
		 }
		size_t capacity() const
		{
			return _end_capacity - _start;

		}
		 
		
		 vector(const vector<T>& v)
		 {
			 /*_start = new T[v.capacity()];
			 for (size_t i = 0; i < v.size(); ++i)
			 {
				 _start[i] = v._start[i];
			 }
			 _finish = _start + v.size();
			 _end_capacity = _start + v.capacity();*/
			 vector<T> tmp(v.begin(), v.end());
			 swap(tmp);
		 }
		void swap(vector<T>& v)
		 {
			std::swap(_start, v._start);
			std::swap(_finish, v._finish);
			std::swap(_end_capacity, v._end_capacity);
		 }
		 vector<T>& operator = (vector<T> v)
		 {
			/* if (this != &v)
			 {
				 T* tmp = new T[v.capacity()];
				 memcpy(tmp, v._start, sizeof(T)*v.size());
				 delete[] _start;
				 _start = tmp;
				 _finish = _start + v.size();
				 _end_capacity = _start + v.capacity();
			 }
			 return *this; */ //这是常规思路,可以复用swap函数
			 swap(v);
			 return *this;
		 } 

		 vector(size_t n, const T& val = T())
		 {
			 reserve(n);
			 for (size_t i = 0; i<n; ++i)
			 {
				 push_back(val);
			 }
		 }
		 vector(int n, const T& val = T())
		 {
			 reserve(n);
			 for (int i = 0; i<n; ++i)
			 {
				 push_back(val);
			 }
		 }
		 template<class InputIterator>
		 vector(InputIterator first, InputIterator last)
		 {
			 while (first != last)
			 {
				 push_back(*first);
				 ++first;
			 }
		 }


		 void resize(size_t n, T val = T())
		 {
			 if (n < size())
			 {
				 _finish = _start + n;
			 }
			 else
			 {
				 if (n>capacity())
				 {
					 reserve(n);
				 }
				 while (_finish != _start + n)
				 {
					 (*_finish) = val;
					 ++_finish;
				 }
			 }

		 }
		 void reserve(size_t n)
		 {
			 if (n > capacity())
			 {
				 T* tmp = new T[n];
				 size_t size1 = size();
				 if (_start)
				 {
					 for (size_t i = 0; i < size1; ++i)
					 {
						 tmp[i] = _start[i];
					 }
				     delete[] _start;
				 }
				 _start = tmp;
				 _finish = _start + size1;
				 _end_capacity = _start + n;
			 }
		 }
		 void push_back(const T& x)
		 {
			 if (_finish == _end_capacity)
			 {
				 reserve(capacity() == 0 ? 4 : capacity() * 2);
			 }
			 *_finish = x;
			 ++_finish;
		 }
		 void pop_back()
		 {
			 assert(!empty());
			 --_finish;
		 }
		 iterator insert(iterator pos, const T& val)
		 {
			 assert(pos <= _finish);
			 assert(pos >= _start);
			 if (_finish == _end_capacity)
			 {
				 int len = pos - _start;
				 reserve(capacity() == 0 ? 4 : capacity() * 2);
				 pos = _start + pos;
			 }
			 iterator end = _finish - 1;
			 while(end>=pos)
			 {
				 *(end+1) = *end;
				 --end;
			 }
			 *pos = val;
			 ++_finish;
			 return pos;
		 }
		iterator erase(iterator pos)
		 {
			 assert(pos <= _finish);
			 assert(pos >= _start);
			 itetator first = pos + 1;
			 while (first!=_finish )
			 {
				 *(first - 1) = *first;
				 ++first;
			 }
			 --_finish;
			 return pos;
		 }
		 bool empty()
		 {
			 return _start == _finish;

		 }
		 T& operator[](size_t pos)
		 {
			 assert(pos < size());
			 return _start[pos];

		 }
		 const T& operator[](size_t pos) const
		 {
			 assert(pos < size());
			 return _start[pos]

		 }
	 private:
		 iterator _start=nullptr;
		 iterator _finish=nullptr;
		 iterator _end_capacity=nullptr;
	 };



	 

#include<iostream>
using namespace std;
#include"simulate_vector.h"



class Solution {
public:
	nza::vector<nza::vector<int>> generate(int numRows) {
		nza::vector<nza::vector<int>> vv;
		vv.resize(numRows, nza::vector<int>());
		for (size_t i = 0; i < vv.size(); ++i)
		{
			vv[i].resize(i + 1, 0);
			vv[i][0] = vv[i][vv[i].size() - 1] = 1;
		}

		for (size_t i = 0; i < vv.size(); ++i)
		{
			for (size_t j = 0; j < vv[i].size(); ++j)
			{
				if (vv[i][j] == 0)
				{
					vv[i][j] = vv[i - 1][j] + vv[i - 1][j - 1];
				}
			}
		}

		return vv;
	}
};

void test1()
{
	nza::vector<int> v1;
	v1.push_back(14);
	v1.push_back(15);
	v1.push_back(16);
	v1.push_back(17);
	v1.push_back(18);


	for (size_t i = 0; i < v1.size(); ++i)
	{
		cout << v1[i] << " ";
	}
	cout << endl;

	v1.pop_back();
	v1.pop_back();

	nza::vector<int>::iterator it = v1.begin();
	while (it != v1.end())
	{
		cout << *it << " ";
		++it;
	}
	cout << endl;

	v1.pop_back();
	v1.pop_back();

	for (auto v : v1)
	{
		cout << v << " ";
	}
	cout << endl;

}
void test2()
{
	std::string s1("hello");
	nza::vector<int> v3(s1.begin(), s1.end());
	for (auto e : v3)
	{
		cout << e << " ";
	}
	cout << endl;
}
void test3()
{
	nza::vector<std::string> v3(3, "dddddddddd");
	for (auto e : v3)
	{
		cout<<e<<" ";
	}
	cout << endl;
	nza::vector<std::string> v4(v3);
	for (auto e : v4)
	{
		std::cout << e << " ";
	}
	cout << endl;

	v4.push_back("kkkkkkkkkkk");
	v4.push_back("kkkkkkkkkkk");
	v4.push_back("kkkkkkkkkkk");
	for (auto e : v4)
	{
		cout << e << " ";
	}
	cout << endl;
}
void test4()
{

	nza::vector<nza::vector<int>> ret =Solution().generate(5);
	for (size_t i = 0; i < ret.size(); ++i)
	{
		for (size_t j = 0; j < ret[i].size(); ++j)
		{
			cout << ret[i][j] << " ";
		}
		cout << endl;
	}
	cout << endl;

}
void test5()
{
	nza::vector<int> v;
	v.push_back(1);
	v.push_back(2);
	v.push_back(3);
	v.push_back(4);
	nza::vector<int>::reverse_iterator  s= v.rbegin();
	while (s != v.rend())
	{
		cout << *s << " ";
		++s;
	}
	cout << endl;

}
int main()
{
	test1();
	test2();
	test3();
	test4();
	test5();
	return 0;
}

（3）反向迭代器实现结果

文章来源地址https://www.toymoban.com/news/detail-416596.html

到了这里，关于C++【栈&队列(3种)&反向迭代器】的文章就介绍完了。如果您还想了解更多内容，请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章，希望大家以后多多支持TOY模板网！