容器适配器-栈，队列，优先级队列

New Young

已于 2022-11-29 23:27:01 修改

阅读量178

点赞数 1

分类专栏： C++ 文章标签：算法大数据 c++

于 2022-07-16 21:44:19 首次发布

本文链接：https://blog.csdn.net/qq_55439426/article/details/125825567

版权

C++ 专栏收录该内容

22 篇文章 2 订阅

订阅专栏

文章目录

前言：
适配器
容器适配器

前言：

博主收集的资料New Young，连载中。
博主收录的问题:New Young
转载请标明出处：New Young

适配器

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

就像：不同的充电线，插入到同一个充电头后，都可以依据不同手机完成充电这一需求

同样如果把充电线比作容器（string，vector,list）,通过复用容器中的功能就实现另外一类功能的类—这称为容器适配器：stack，queue,priority_queue

容器适配器

stack

stack是一种容器适配器，专门用在具有后进先出操作的上下文环境中，其删除只能从容器的一端进行元素的插入与提取操作。
stack的底层容器可以是任何标准的容器类模板或者一些其他特定的容器类，这些容器类应该支持以下
操作：
empty：判空操作
back：获取尾部元素操作
push_back：尾部插入元素操作
pop_back：尾部删除元素操作
依据要求，标准容器vector、deque、list均符合这些需求，默认情况下，如果没有为stack指定特定的底层容器，默认情况下使用deque
```
template <class T, class Container = deque<T> > class stack;
```

queue

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

priority_queue（优先级队列）

优先级队列是一种容器适配器，其底层类似堆，因此关于建堆的向上，向下调整算法，堆排序，TopK等其都要支持。
底层容器可以是任何标准容器类模板，也可以是其他特定设计的容器类。容器应该可以通过随机访问迭代器访问，并支持以下操作：
1. empty()：检测容器是否为空
2. empty()：检测容器是否为空
3. front()：返回容器中第一个元素的引用
4. push_back()：在容器尾部插入元素
5. pop_back()：删除容器尾部元素
标准容器类vector和deque。默认情况下，如果没有为特定的priority_queue类实例化指定容器类，则使用vector
堆的向上，向下调整算法都要依据建大堆还是小堆，进行修改，为了避免冗余，因此使用一个模板类，通过==运算符（）==来进行修改-----调用（），对象看起来就像函数一样

请添加图片描述

priority_queue.h代码

#pragma once

#include"Vector.h"
namespace My_Pq
{

	template<class T>
	struct Less
	{

		bool operator()(const int& x,const  int& y)
		{
			return x < y;
		}

	};
	template<class T>
	struct Greater
	{

		bool operator()(int x, int y)
		{
			return x > y;
		}

	};
	//建大堆
	template<class T,class Container= My_Vet::vector<int>,class Compare=Less<T>>
	class priority_queue
	{

	public:
		priority_queue()//调用自定义的构造函数
		{
			;
		}
		template <class InputIterator>
		priority_queue(InputIterator first, InputIterator last)
			:_con(first,last)
		{
			
			//建堆
			int lastchild = _con.size() - 1;
			int parent = (lastchild - 1) / 2;
			for (; parent >= 0; --parent)
			{
				Adjust_down(parent);
			}
		}
		void push(const T& value)
		{
			_con.push_back(value);
			Adjust_up(_con.size() - 1);
		}

		void pop()
		{
			std::swap(_con[0], _con[_con.size() - 1]);
			_con.pop_back();
			Adjust_down(0);
		
		}
		bool empty()
		{

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


	private:
		void Adjust_down(size_t parent)
		{

			size_t child = parent * 2 + 1;
			while (child < _con.size())
			{
				
				if (child + 1 < _con.size() && _con[child + 1] > _con[child])
				{
					child = child + 1;
				}
				//使用匿名对象
				if (Compare()(_con[parent], _con[child]))
				{
					std::swap(_con[child], _con[parent]);
					parent = child;
					child = parent * 2 + 1;
				}
				else
				{
					break;
				}
			}
		}

		void Adjust_up(size_t child)
		{
			size_t parent = (child - 1) / 2;
			while (child > 0)
			{

				if (child > 0 && Compare()(_con[parent], _con[child]))
				{
					std::swap(_con[child], _con[parent]);
					child = parent;
					parent = (child - 1) / 2;
				}
				else
				{
					break;
				}
			}


		}

		Container _con;
	};


}