C++ stack&queue

Posted 2021-10-03 L_add

stack&&queue

• stack
• • 模拟实现stack
• queue
• • 模拟实现queue
  • priority_queue
  • • 仿函数
    • 模拟实现priority_queue
• 容器适配器
• • STL标准库中stack和queue的底层结构
  • deque
  • • deque的优势与缺陷
    • 为什么选择deque作为stact和queue的底层默认容器

stack

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

模拟实现stack

#pragma once
#include <vector>
#include <list>
namespace Stack
{
	//常规实现数据结构的操作
	//template<class T>
	//class stack
	//{
	//public:
	//	//...
	//private:
	//	T* a;
	//	size_t _size;
	//	size_t _capacity;
	//};
	//容器适配器
	//template<class T,class Container = std::list<T>>
	//template<class T,class Container = std::vector<T>>
	template<class T, class Container = std::deque<T>>
	class stack
	{
	public:

		void push(const T& x)
		{
			_con.push_back(x);
		}
		void pop()
		{
			_con.pop_back();
		}
		T top()
		{
			return _con.back();
		}
		size_t size()
		{
			return _con.size();
		}
		bool empty()
		{
			return _con.empty();
		}
	private:
		Container _con;

	};
}

queue

1、队列是一种容器适配器，专门用于在FIFO上下文(先进先出)中操作，其中从容器一端插入元素，另一端提取元素。
2.队列作为容器适配器实现，容器适配器即将特定容器类封装作为其底层容器类，queue提供一组特定的成员函数来访问其元素。元素从队尾入队列，从队头出队列。
3.底层容器可以是标准容器类模板之一，也可以是其他专门设计的容器类。
4.标准容器类deque和list满足了这些要求。默认情况下，如果没有为queue实例化指定容器类，则使用标准容器deque。

模拟实现queue

namespace Queue
{
	template <class T,class Container = std::deque<T>>
	class queue
	{
	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();
		}
	private:
		Container _con;
	};
}

priority_queue

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

仿函数

//仿函数-》函数对象 这个类的对象可以像函数一样去使用
//为什么用仿函数? 函数指针不好用
struct LessInt
{
	bool operator()(int i, int n)
	{
		return i < n;
	}
};
int main()
{
	LessInt li;
	//cout<<li.operator()(3,4)<<endl;
	cout<<li(2, 4)<<endl;
	return 0;
}

模拟实现priority_queue

namespace PQ
{
	template<class T>
	struct less
	{
		bool operator()(const T& i, const T& n)
		{
			return i < n;
		}
	};
	template<class T>
	struct greater
	{
		bool operator()(const T& i, const T& n)
		{
			return i > n;
		}
	};
	template<class T,class Container = std::vector<T>,class Compare = less<T>>
	class priority_queue
	{
	public:
		//typedef Container::value_type vt;// 报错 类模板没有实例化，编译器就不能去类中找
		//类模板，不会被留下，留下的具体实例化类模板中的T以后的类
		typedef typename Container::value_type vt;//typename/class 告诉编译器这后面是类型名称
		//等类模板实例化以后再去找它中的value_type
		void Adjustup(size_t child)
		{
			Compare com;
			size_t  parent = (child - 1) / 2;
			while (child > 0)
			{
				//if (_con[parent] > _con[child])
				if (com(_con[parent], _con[child]))
				{
					std::swap(_con[parent], _con[child]);
					child = parent;
					parent = (child - 1) / 2;
				}
				else
				{
					break;
				}
			}
		}
		void push(const T& x)
		{
			_con.push_back(x);
			Adjustup( _con.size() - 1);//向上调整
		}
		void Adjustdown(size_t parent)
		{
			Compare com;
			size_t child = parent * 2 + 1;
			while (child < _con.size())
			{
				//if (child + 1 < _con.size() && _con[child] > _con[child + 1])
				if (child + 1 < _con.size() && (com(_con[child] , _con[child + 1])))
				{
					child++;
				}
				//if (_con[parent] > _con[child])
				if (com(_con[parent] , _con[child]))
				{
					std::swap(_con[parent], _con[child]);
					parent = child;
					child = parent * 2 + 1;
				}
				else
					break;
			}
		}
		void pop()
		{
			std::swap(_con[0], _con[_con.size() - 1]);
			_con.pop_back();
			Adjustdown(0);//向下调整

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

容器适配器

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

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

deque

deque(双端队列)：是一种双开口的“连续”空间的数据结构，双开口指可以在头尾两端进行插入和删除操作，且时间复杂度为O(1)，比vector头插效率高，比list空间利用率高。

deque并不是真正连续的空间，而是由一段段连续的小空间拼接而成，实际上deque类似于一个动态二维数组
双端队列底层是一段假象的连续空间，实际是分段连续的，为了维护其“整体连续”以及随机访问的假象，落在deque的迭代器身上

deque的优势与缺陷

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

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

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

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