容器适配器的介绍和模拟实现

💗 💗 博客:小怡同学
💗 💗 个人简介:编程小萌新
💗 💗 如果博客对大家有用的话，请点赞关注再收藏 🌞

Stack的介绍

1. stack是一种容器适配器，专门用在具有后进先出操作的上下文环境中。专门用在具有后进先出操作的上下文环境中，其删除只能从容器的一端进行
   元素的插入与提取操作。
2. 标准容器vector、deque、list均符合这些需求，默认情况下，如果没有为stack指定特定的底层容器，默认情况下使用deque。
   //容器适配器简单来说就是封装其它容器进行使用

stack的常见类函数

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

stack的模拟实现

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

namespace zjy
{
	template <class T, class Container = deque<T>>
	class MyStack
	{
	public:
		void Push(const T& x)
		{
			_con.push_back(x);
		}
		void Pop()
		{
			_con.pop_back();
		}
		T& Top()
		{
			return _con.back();
		}
		bool Empty()
		{
			return _con.empty();
		}
		size_t Size()
		{
			return _con.size();
		}
		void Print()
		{
			for (auto& st : _con)
			{
				cout << st << endl;
			}
		}
	private:
		Container _con;
	};

};

Queue的介绍

1. 队列是一种容器适配器，专门用于在FIFO上下文(先进先出)中操作，其中从容器一端插入元素，另一端
   提取元
   2.标准容器类deque和list满足了这些要求。默认情况下，如果没有为queue实例化指定容器类，则使用标
   准容器deque。

Queue的常见类函数

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

Queue的模拟实现

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

namespace zjy
{
	template <class T, class Container = deque<T>>
	class MyStack
	{
	public:
		void Push(const T& x)
		{
			_con.push_back(x);
		}
		void Pop()
		{
			_con.pop_front();
		}
		T& Front()
		{
			return _con.front();
		}
		T& Back()
		{
			return _con._back();
		}

		bool Empty()
		{
			return _con.empty();
		}
		size_t Size()
		{
			return _con.size();
		}
		void Print()
		{
			for (auto& st : _con)
			{
				cout << st << endl;
			}
		}
	private:
		Container _con;
	};

};

Priority_queue的介绍和模拟实现

1. 优先队列是一种容器适配器
2. 标准容器类vector和deque满足这些需求。默认情况下，如果没有为特定的priority_queue类实例化指
   定容器类，则使用vector。
   3.在vector上又使用了堆算法将vector中元素构造成
   堆的结构，因此priority_queue就是堆，所有需要用到堆的位置，都可以考虑使用priority_queue。

Priority_queue的常见类函数

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

Priority_queue的模拟实现

优先队列的模拟实现会运用到仿函数
仿函数的简介;就是使一个类的使用看上去像一个函数。其实现就是类中实现一个operator()，这个类就有了类似函数的行为，就是一个仿函数类了。

namespace zjy
{

	template<class T, class Container = vector<T>, class Compare = less<T> >//less<T>为大堆
	class priority_queue
	{
	private:
		void AdjustUp(int child)//向上调整，这里增加元素，层层向上调整
		{
			Compare  com;
			int parent = (child - 1) / 2;
			while (parent >= 0)
			{
				Compare com;
				if (com(_con[parent] , _con[child]))
				{
					swap(_con[parent], _con[child]);
					 child = parent;
					parent = (child - 1) / 2;

				}
				else
				{
					break;
				}
				
			}
		}
		void AdjustDown(int parent)//向下调整，这里删除，建堆会使用到
		{
			Compare com;
			int child = parent* 2+1;
			
			while (child < _con.size())
			{
				if ((child + 1) < _con.size() && com( _con[child],  _con[child + 1]))
				{
					child++;
				}
				if (com(_con[child] , _con[parent]))
				{
					std::swap(_con[child],_con[parent]);
					parent = child;
					child = parent * 2 + 1;
				}
				else
				{
					break;
				}
				
			}
		}
		const T& top()
		{
			return _con[0];

		}
		bool empty()
		{
			return _con.empty();
		}
		size_t size()
		{
			return _con.size();
		}
	public:
		template<class InputIterator>
		priority_queue(InputIterator first, InputIterator last)//迭代器构造
		{
			while (first != last)
			{
				_con.push_back(*first);
				first++;
			}
			for (int i = (_con.size() - 2) / 2; i >= 0; i--)
			{
				AdjustDown(i);
			}
		}
		void push(const T& x)
		{
			_con.push_back(x);
			
			AdjustUp(_con.size()-1);
		}
		void pop()
		{
			std::swap(_con[0],_con[_con.size()-1]);
			_con.pop_back();
			AdjustDown(0);

		}
 	private:
		Container _con;
	};
}

反向迭代器的的介绍和模拟实现

反向迭代器是一种反向遍历容器的迭代器
//这里直接封装正向迭代器

	template<class iterator , class Ref  ,class Ptr>
	class reverse_iterator
	{
	public:
		typedef reverse_iterator<iterator, Ref, Ptr> self;
		reverse_iterator(const iterator& _it)
			:it(_it)
		{}
		self& operator++()//前置++
		{
			--it;
			return *this;
		}

		self operator++(int)//后置++
		{
			self tmp(it);
			it--;
			return tmp;
		}

		self& operator--() 
		{
			it++;
			return *this;
		}

		self operator--(int)
		{
			self tmp(it);
			it++;
			return tmp;
		}

		bool operator!=(const self& n) const
		{
			return it != n.it;
		}

		bool operator==(const self& n) const
		{
			return it == n.it;
		}


		Ref operator*() //解引用访问数据
		{ 
			iterator tmp = it;
			return *(--tmp);//因为反向所以解引用前一位
		}

		Ptr operator->()
		{
			return  &(operator*());
		}
		
	private:
		iterator it;
	};
}