模拟实现简单栈和队列

一.栈的模拟实现

stack作为容器适配器实在容器的基础上再进行封装，因此实现较为简单。

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

namespace cls
{
	template<class T,class Container = deque<T>>
	class stack
	{
	public:
		void push(const T& x)
		{
			_con.push_back(x);
		}

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

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

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

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

	private:
		Container _con;
	};

}

二.队列的模拟实现

queue也是容器适配器，默认适配容器为deque，实现与stack基本同理。

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

namespace cls
{ 
	template<class T,class Container  = deque<T>>
	class queue
	{
	public:
		void push(const T& x)
		{
			_con.push_back(x);
		}

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

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

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

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

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

	private:
		Container _con;
	};

}

三.优先级队列

priority_queue底层其实是堆，是基于堆的一些算法实现出来的。它同时也是容器适配器，默认适配容器为vector，以下为模拟实现

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


//仿函数
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 cls
{
	template<class T, class Container = vector<T>,class Compare = Less<T>>
	class priority_queue
	{
	public:
		void AdjustUp(int down)
		{
			Compare com;
			int parent = (down - 1) / 2;
			int child = down;
			while (child > 0)
			{
				if (com(_con[parent], _con[child]))
				{
					swap(_con[parent], _con[child]);
					child = parent;
					parent = (child - 1) / 2;
				}
				else
				{
					break;
				}
			}
		}

		void AdjustDown(int down)
		{
			Compare com;
			int parent = 0;
			int child = parent * 2 + 1;
			while (child <= down)
			{
				if (child+1 <= down && com(_con[child], _con[child+1]))
				{
					++child;
				}
				if (com(_con[parent], _con[child]))
				{
					swap(_con[parent], _con[child]);
					parent = child;
					child = parent * 2 + 1;
				}
				else
				{
					break;
				}
			}
		}

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

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

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

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

	private:
		Container _con;
	};
}

希望这些对大家有所帮助。