C++入门stack和queue适配器介绍+ priority_queue的模拟实现仿函数基本概念提及

Posted 2021-12-24 IT莫扎特

目录

• stack介绍
• queue的介绍和使用
• deque的介绍
• • deque容器的存储结构
• deque的缺陷
• priority_queue的介绍和使用
• 模拟实现
• • 仿函数
  • 框架
  • 堆算法
  • 核心接口

stack介绍

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

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

3. stack的底层容器可以是任何标准的容器类模板或者一些其他特定的容器类，这些容器类应该支持以下
   操作：
   empty：判空操作
   back：获取尾部元素操作
   push_back：尾部插入元素操作
   pop_back：尾部删除元素操作

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

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

stack 的实现较为简单，他是通过一种容器类型来创建出来的容器适配器，下面直接看代码

namespace mzt

	     //     类型         容器类型
	template<class T, class container>
	class stack
	
		
	public:
		stack()  
		//入栈
		void push(const T& val)
		
			_con.push_back(val);
		
		//获取元素个数
		size_t size()  return _con.size(); 
		//判空
		bool empty()  return _con.empty(); 
		// 获取栈顶元素
		T& top()  return _con.back(); 
		//出栈
		void pop()  _con.pop_back(); 

	private:
		container _con;  
		//在stack对象创建的时候,调用构造函数
		//以初始化列表方式初始化 _con成员
	;




void func1()

	//将list类型适配转换stack
	mzt::stack<int, list<int>>st;
	st.push(1);
	st.push(2);
	st.push(3);
	st.push(10);
	while (!st.empty()) 
	
		cout << st.top() << " ";
		st.pop();
	
	cout << endl;
	


void func2()

	//将vector类型适配转换stack
	mzt::stack<int, vector<int>>st;
	st.push(1);
	st.push(2);
	st.push(3);
	st.push(10);
	while (!st.empty()) 
	
		cout << st.top() << " ";
		st.pop();
	
	cout << endl;
	

结论：使用两种容器类型创建的stack容器适配器均符合LIFO原则

queue的介绍和使用

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

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

3. 底层容器可以是标准容器类模板之一，也可以是其他专门设计的容器类。该底层容器应至少支持以下操作:
   empty：检测队列是否为空
   size：返回队列中有效元素的个数
   front：返回队头元素的引用
   back：返回队尾元素的引用
   push_back：在队列尾部入队列
   pop_front：在队列头部出队列

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

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

queue的实现较为简单，他是通过一种容器类型来创建出来的容器适配器，下面直接看代码

template<class T, class container>
	//队尾入，队头出
	class queue 
	
	public:
			queue()  
			//以下均是复用container类型的成员接口函数来实现queue的接口
			void push(const T& val) 
			
				_con.push_back(val); 
			
			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();
			
	private:
		container _con;
		//queue对象创建的时候,调用构造函数
		//以初始化列表方式初始化 _con成员
	;




void func3() 

	//将list类型适配转换queue
	mzt::queue<int, list<int>> q;
	q.push(1);
	q.push(2);
	q.push(3);
	q.push(4);
	while(!q.empty()) 
	
		cout << q.front() << " ";
		q.pop();
	

结论：使用list容器类型创建的queue容器适配器符合FIFO原则

总结：STL的stack和queue是通过容器适配器转换出来的，不是原生实现的，是复用其他容器的接口函数实现的

deque的介绍

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

deque容器的存储结构

和 vector 容器采用连续的线性空间不同，deque 容器存储数据的空间是由一段一段等长的连续空间构成，各段空间之间并不一定是连续的，可以位于在内存的不同区域。

为了管理这些连续空间，deque 容器用数组（数组名假设为 map）存储着各个连续空间的首地址。也就是说，map 数组中存储的都是指针，指向那些真正用来存储数据的各个连续空间

通过建立 map 数组，deque 容器申请的这些分段的连续空间就能实现“整体连续”的效果。换句话说，当 deque 容器需要在头部或尾部增加存储空间时，它会申请一段新的连续空间，同时在 map 数组的开头或结尾添加指向该空间的指针，由此该空间就串接到了 deque 容器的头部或尾部。

map满了怎么办？

如果 map 数组满了就会申请一块更大的连续空间供 map 数组使用，将原有数据（map中原本存放的指针）拷贝到新的 map数组中，然后释放旧的空间。这样子我们在实际增容的过程就不需要考虑数据挪动的问题，只需要管理这个map数组，解决问题的代价相对来说小了很多

双端队列底层是一段假象的连续空间，实际是分段连续的，为了维护其“整体连续”以及随机访问的假象，这个任务落在了deque的迭代器身上

这里的map属于一个指针数组，map数组相当于一个中控管理器，存放的是每一个buff的首地址地址。
cur：指向当前正在遍历的元素；
first：指向当前连续空间的首地址；
last：指向当前连续空间的末尾地址；
node：它是一个二级指针，用于指向 map 数组中存储的指向当前连续空间的指针。

如何实现operator[ ]的随机访问呢？
需要计算访问的第i个元素在哪个buff中，当数据量大了以后效率就变低了

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

deque的缺陷

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

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

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

总结：
dequeue一般是作为stack和queue的默认适配容器，适合头尾插入删除，不适合大量中间插入删除，不适合大量的随机访问

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

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

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

void func4() 

	int arr[] = 1,2,4,59,32,64,45,6;
	//使用迭代器区间创建一个priority_queue对象
	priority_queue<int>q(arr, arr + sizeof(arr) 
							/ sizeof(arr[0]));
	
	while (!q.empty()) 
	
		//取出堆顶的元素
		cout << q.top() << " ";
		//弹出堆顶的元素
		q.pop();
	

从打印的结果可以看出，priority_queue这个容器默认是使用大堆存储的结构了

void func4() 

	vector<int> v;
	v.push_back(51);
	v.push_back(20);
	v.push_back(31);
	v.push_back(14);
	v.push_back(64);
	v.push_back(44);
	//创建这个priority_queue对象的时候
	//就已经可以指顶他是小堆存储的结构
	//这里的greater是一个仿函数，可调用对象，具体细节后面讲
	priority_queue<int, vector<int>, greater<int> >q;
	for (auto&e : v) 
	
		q.push(e);
	
	while(!q.empty()) 
	
		cout << q.top() << " ";
		q.pop();
		
	

从打印的结果可以看出，priority_queue这个容器已经使用小堆存储的结构了

模拟实现

仿函数

模拟实现priority_queue之前我们必须先搞懂这个less，因为Compare默认的缺省参数就是less

template <class T, 
class Container = vector<T>,
					//less<typename Container::value_type>
					//属于一种内嵌类型
					//编译器在实际中其实并不知道Container
					//的类型只有通过模板被实例化后才能知道
					//Container 的类型，这里的typename 
					//只是告诉编译器Container::value_type
					//是一个具体的类型，而value_type是
					//Container类中的一个内嵌类型
					
class Compare = less<typename Container::value_type>  >class priority_queue;

这里我们先提及C++一个叫做仿函数的概念他是一个可调用对象，函数对象是专门设计用于类似于函数语法的对象。 在c++中，这是通过在类中定义成员函数operator()来实现的.
先看文档: 链接.

//源码
template <class T> struct less 
: binary_function <T,T,bool> //继承 


  bool operator() (const T& x, const T& y) const 
   
  	return x<y;
  
  
;

//这里涉及了一个继承的知识，目前博主并没有写相关的继承文章，
//所以这里将继承去掉，先看代码的主逻辑
template <class T> struct less  
  //通过重载operator()的方式做到将对象像一个函数似的调用
  bool operator() (const T& x, const T& y) const 
   
  	  //返回比较的结果
  	  return x<y;
  
;

框架

如果前面的知识你都看懂了，说明你的C++基础还是有的，那在这里也不多废话，先看框架，结合前面的所学知识

	//搭架子，我们知道容器适配器的概念就是通过一种容器类型构造出
	//另一中容器类型
	//而堆相关的算法也都是需要支持随机访问的，这里默认给vector类型
	//而像这种构造函数/析构函数我们也就都不需要写了，
	//因为Container类型的容器会自带
	template<class T, class Container = vector<T>, class Compare = less<T>>
	class priority_queue
	
	public:
			//成员函数
		
	private:
			Container _con;//Container 类型对象，
						   //模板实例化后才得知具体类型
	;

堆算法

这块与我们以前学习堆的时候使用的逻辑是一样的如果具体的细节忘了的话，可以翻博主之前的数据结构文章，后面为了使用仿函数，博主会将判断大小这里使用仿函数替换掉，读者先看当前的代码就行

//向下调整算法
void AdjustDown(Container &_con, int begin, int end)

	int parent = begin;
	int child = parent * 2 + 1;
	while (child < end)
	
		if (child + 1 < end && _con[child + 1] > _con[child])
		
			child++;
		
		if (_con[child] > _con[parent] ) 
		
			swap(_con[child], _con[parent]);
			parent = child;
			child = parent * 2 + 1;
		
		else 
		
			break;
		
	

//向上调整算法
void AdjustUp(Container& _con,int child)

	int parent = (child - 1) / 2;
	while (child > 0) 
	
		if(_con[child] > _con[parent])
		
			swap(_con[child],_con[parent]);
			child = parent;
			parent = (child - 1) / 2;
		
		else 
		
			break;
		
	

套用仿函数的写法

这里博主先简单的介绍一下什么叫做仿函数，仿函数也叫做可调用对象，而其实他的原理是重载一个类的operator()运算符，使这个对象能像函数一样被调用，具体看以下代码

template <class T>
struct less

	bool operator() (const T& child, const T& parent)
	
		return child < parent;
	
;

template <class T>
struct greater

	bool operator() (const T& child, const T& parent)
	
		return child > parent;
	
;

具体写法

void AdjustDown(Container &_con, int begin, int end)

	//创建可调用对象
	Compare com;
	int parent = begin;
	int child = parent * 2 + 1;
	while (child < end)
	
		//这里我们再比较的时候就不再像之前那样使用符号比较了
		//com(_con[child] , _con[child + 1]))
		//上面这行代码实际展开的时候如以下
		//com.operator()(_con[child],  _con[child + 1])
		if (child + 1 < end && 
		com(_con[child] , _con[child + 1]))
		
		
			child++;
		
		//同上
		if (com(_con[parent], _con[child]) )
		
			swap(_con[child], _con[parent]);
			parent = child;
			child = parent * 2 + 1;
		
		else 
		
			break;
		


	



void AdjustUp(Container& _con,int child)

	Compare com;
	int parent = (child - 1) / 2;
	while (child > 0) 
	
		//同上
		if(com(_con[parent], _con[child]))
		
			swap(_con[child],_con[parent]);
			child = parent;
			parent = (child - 1) / 2;
		
		else 
		
			break;
		
	

核心接口

回到我们之前所说的容器适配器的概念，容器适配器并不是一个原生的适配器，而是通过一个容器的类型来创建的一个容器，当然使用了这个Container类型的容器，同样的在实现具体的适配器接口函数过程中也可以采用复用Container类型的接口函数，和之前的stack和queue也是一样的，这里就不再继续

//入堆
void push(const T& val)

	_con.push_back(val);
	AdjustUp(_con, _con.size() - 1);

//出堆
void pop() 

	int end = _con.size() - 1;
	swap(_con[end], _con[0]);
	_con.pop_back();
	//向下调整
	AdjustDown(_con, 0, end);

//获取堆顶元素
T& top() 

	return _con[0];


bool empty() 

	return _con.empty();


size_t size() 

	return _con.size();

全部代码博主已经放在git上了，欢迎大家来访
链接: git.