【C++】优先级队列(容器适配器)

chian-ocean2024-08-09 15:41

欢迎来到我的Blog，点击关注哦💕

前言

string vector list 这种线性结构是最基础的存储结构，C++（STL）container很好的帮助我们数据存储的问题。

容器适配器

介绍

  • 容器适配器是C++标准模板库（STL）中的一种设计模式，它允许将一个容器的接口转换为另一个接口，从而提供不同的操作和行为。
  • 容器适配器通常用于封装现有容器，以实现特定的数据结构特性，如栈（后进先出）、队列（先进先出）和优先队列（根据优先级排序）。

应用

  • 栈（stack） ：栈是一种后进先出的数据结构，其操作包括入栈（push）、出栈（pop）、查看栈顶元素（top）等。栈适配器可以基于多种底层容器实现，如vector、deque或list.

  • 队列（queue） ：队列是一种先进先出的数据结构，其操作包括入队（push）、出队（pop）、查看队首元素（front）和查看队尾元素（back）。队列适配器同样可以基于deque或list实现，以适应不同的性能需求.

  • 优先队列（priority_queue） ：优先队列是一种特殊的队列，它根据元素的优先级进行排序。其底层容器通常是vector或deque，并通过堆算法维护元素的优先级顺序。优先队列适配器提供了插入和删除具有最高优先级元素的操作.

双重结束队列（双端队列（deque））

特点

  • 双端操作效率：支持在两端进行快速的插入和删除操作。
  • 随机访问：可以通过索引直接访问容器中的元素。
  • 无需预先分配固定大小 ：与vector不同，deque不需要在创建时指定大小，它可以根据需要动态增长。
  • 内存分配策略 ：deque不需要像vector那样一次性分配大量内存，而是分散在内存中，这有助于减少内存碎片。

存储结构

双端队列底层是一段假象的连续空间，实际是分段连续的，为了维护其"整体连续"以及随机访问的假象，落 在了deque的迭代器身上，因此deque的迭代器设计就比较复杂，如下图所示：

List 、vector deque对比

对比维度 Vector Deque List
内存连续性 是 否 否
随机访问性能 O(1) O(1) 但可能不如Vector O(n)
插入/删除性能 非末尾O(n) 两端O(1), 中间O(n) 两端及中间O(1)
内存重用效率 扩容时需移动元素 两端添加删除不需移动 不适用
内存分配模式 动态数组，连续内存 分段连续内存 非连续内存
迭代器失效 可能 不会 不会
支持的操作 [] 访问、.at() 等 [] 访问、.at() 等 [] 访问、.at() 等
内存管理开销 高（扩容时） 中等（两端操作） 低
适用场景 需要快速随机访问且元素数量稳定 需要两端快速插入删除，随机访问需求适中 频繁插入删除，不关心随机访问

栈（stack）

栈的介绍

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

栈的模拟实现

利用容器适配器 的设计原理，很容易实现栈

  • 将栈放mystack的命名空间，以防止和库中冲突
  • 类模板设计container可以给缺省参数，默认deque(容器适配器)
  • 在里面利用deque的接口实现
cpp 复制代码 
namespace mystack
{
	template<class T, class Container = std::deque<T>>
	class stack
	{
	public:

		void push_back(const T& x)
		{
			_con.push_back(x);
		}
		void pop()
		{
			_con.pop_back();
		}
		size_t size()
		{
			return _con.size();
		}
		T& top()
		{
			return _con.back();
		}

		bool empty()
		{
			return _con.empty();
		}
	private:

		Container _con;
	};
}

队列

队列介绍

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

队列模拟实现

  • 将栈放myqueue的命名空间，以防止和库中冲突
  • 类模板设计container可以给缺省参数，默认deque(容器适配器)
  • 在里面利用deque的接口实现
cpp 复制代码 
namespace myqueue
{
	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();
		}
		size_t size()
		{
			return _con.size();
		}
		T& front()
		{
			return _con.front();
		}

		bool empty()
		{
			return _con.empty();
		}
	private:

		Container _con;
	};
}

优先级队列（priority_queue）

基本原理

  • 优先级队列通常在内部使用堆数据结构来维护元素的优先级。
  • 堆是一种完全二叉树，可以是最大堆或最小堆。
  • 在最大堆中，父节点的值总是大于或等于其子节点的值，而在最小堆中，父节点的值总是小于或等于其子节点的值。
  • 插入操作通过在堆的适当位置插入新元素并进行上调整（heapify-up）来维持堆的性质。
  • 删除操作则涉及到移除堆顶元素（优先级最高的元素）并进行下调整（heapify-down），以恢复堆的结构。

priority_queue介绍

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

优先级模拟实现 （可以参考）

仿函数

  • 仿函数（Functor）是C++中的一个编程概念，它指的是一个类或结构体，通过重载函数调用运算符operator()，使得这个类或结构体的对象可以像函数一样被调用。
  • 仿函数可以包含状态，因为它们是对象，可以在构造函数中初始化状态，并在operator()中使用该状态。
  • 仿函数可以作为参数传递给其他函数，包括STL算法中的函数，从而提供灵活的编程模型.

这个就是一个仿函数

cpp 复制代码 
//小于
template<class T>
	class Less
	{
	public:
		bool operator()(const T& a,const T& b)
		{
			return a < b;
		}
	};
//大于
template<class T>
	class Greater
	{
	public:
		bool operator()(const T& x, const T& y)
		{
			return x > y;
		}
	};

priority_queue两个关键

向下建堆

  • 确定起始点 ：从最后一个非叶子节点开始向下建堆，这个节点也被称为堆的最后一个非叶子节点。在完全二叉树中，最后一个非叶子节点的索引可以通过 (n - 1 - 1) / 2 计算得到，其中 n 是数组的长度。
  • 执行向下调整：对每个非叶子节点执行向下调整操作，确保该节点与其子节点组成的子树满足堆的性质。向下调整的过程涉及到与子节点的比较和必要时的交换，直至到达堆的顶部或直到父节点不再违反堆的性质。
  • 迭代过程：从最后一个非叶子节点开始，逐步向上调整，直到根节点。每次调整后，更新当前节点的索引，以便进行下一次调整。
  • 完成建堆：重复步骤2和步骤3，直到根节点也满足堆的性质，此时整个数组就构建成了一个堆。
cpp 复制代码 
void AdjustDown(size_t parent)
{
    compare com;//仿函数

    size_t child = parent * 2 + 1;
    //if (child+1< _con.size() && _con[child] < _con[1+child])
    if (child + 1 < _con.size() && com(_con[child] ,_con[1 + child]))//和上面等价

    {
        ++child;
    }
    while (child <_con.size())
    {
        if (com(_con[parent], _con[child]))
        {
            std::swap(_con[child], _con[parent]);
            parent = child;
            child = parent * 2 + 1;
        }
        else
        {
            break;
        }
    }
}

向上建堆

  • 初始化堆大小**：设置堆的大小为数组的大小，即 n。
  • 从最后一个非叶子节点开始向上调整 ：在完全二叉树中，最后一个非叶子节点的索引为 floor((n - 1) / 2)。从这个节点开始向上调整，确保每个节点都满足大根堆的性质。
  • 执行向上调整操作：对于每个非叶子节点，检查其与子节点的关系，并进行必要的交换，以确保父节点的值大于或等于其子节点的值。如果子节点中有一个或两个，选择较大的子节点与父节点进行比较。如果父节点的值小于子节点的值，交换它们的位置，并重新设置父节点为当前子节点，继续向上调整。
  • 重复步骤2和3：直到达到根节点，即堆的第一个元素。
cpp 复制代码 
void AdjustUp(int child)
{
    compare com;

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

}

初始化数据

迭代器初始化

  • 模板嵌套给，迭代器初始化

  • 依次push数据，在进行堆的建立

cpp 复制代码 
template<class InputIterator>
void push_back(InputIterator first, InputIterator last)
	{
		while (first != last)
		{
			_con.push_back(*first);
			++first;
		}

		//向下建堆
		for (int i = (_con.size() - 2) / 2; i >= 0; i--)
		{
			AdjustDown(i);
		}
	}

pop数据

  • 将一个个数据和最后一个数据进行交换（目的：保持当前堆的结构）
  • pop出数据，将第一个数据进行向下调整
cpp 复制代码 
void pop()
{
	swap(_con[0], _con[_con.size() - 1]);
		
	_con.pop_back();

	AdjustDown(0);
}

push数据

  • 将数据进行尾插入，进行向上调整
cpp 复制代码 
void push(const T& x)
{
    _con.push_back(x);

    AdjustUp(_con.size() - 1);
}

priority_queue operators

  • top数据，返回首个数据；
  • 其他常见操作，采取容器适配器设计模式的操作
cpp 复制代码 
namespace mypriority_queue
{
	template<class T, class container = std::vector<T>,class compare = Less<T>>

	class priority_queue
	{
	public:
		const T& top()
		{
			return _con[0];
		}
		size_t szie()
		{
			return _con.size();
		}

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

	private:
		container _con;
	};

}

源码（优先级队列）

cpp 复制代码 
namespace mypriority_queue
{
	template<class T>
	class Less
	{
	public:
		bool operator()(const T& a,const T& b)
		{
			return a < b;
		}
	};

	template<class T>
	class Greater
	{
	public:
		bool operator()(const T& x, const T& y)
		{
			return x > y;
		}
	};

	template<class T, class container = std::vector<T>,class compare = Less<T>>

	class priority_queue
	{


		void AdjustDown(size_t parent)
		{
			compare com;

			size_t child = parent * 2 + 1;
			//if (child+1< _con.size() && _con[child] < _con[1+child])
			if (child + 1 < _con.size() && com(_con[child] ,_con[1 + child]))

			{
				++child;
			}
			while (child <_con.size())
			{
				if (com(_con[parent], _con[child]))
				{
					std::swap(_con[child], _con[parent]);
					parent = child;
					child = parent * 2 + 1;
				}
				else
				{
					break;
				}
			}
		}

		void AdjustUp(int child)
		{
			compare com;

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

	public:
		template<class InputIterator>
		void push_back(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 pop()
		{
			swap(_con[0], _con[_con.size() - 1]);
			
			_con.pop_back();

			AdjustDown(0);
		}

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

		void push(const T& x)
		{
			_con.push_back(x);

			AdjustUp(_con.size() - 1);
		}
		size_t szie()
		{
			return _con.size();
		}

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

	private:
		container _con;
	};

}

向下建堆

for (int i = (_con.size() - 2) / 2; i >= 0; i--)

{

AdjustDown(i);

}

}

复制代码 
	void pop()
	{
		swap(_con[0], _con[_con.size() - 1]);
		
		_con.pop_back();

		AdjustDown(0);
	}

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

	void push(const T& x)
	{
		_con.push_back(x);

		AdjustUp(_con.size() - 1);
	}
	size_t szie()
	{
		return _con.size();
	}

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

private:
	container _con;
};

}

复制代码
相关推荐
浮游本尊13 分钟前
Java学习第27天 - 微服务安全与云原生架构
java
m0_7369270413 分钟前
使用 Python 将 PowerPoint 转换为 Word 文档
java·开发语言·后端·职场和发展·c#
杜子不疼.22 分钟前
【Rust】路由匹配与参数提取：从 match 语句到 axum 的类型魔法
开发语言·后端·rust
夜晚中的人海41 分钟前
【C++】位运算算法习题
开发语言·c++·算法
稚辉君.MCA_P8_Java44 分钟前
Java 基本数据类型 - 四类八种
java·linux·后端·mysql·架构
裸奔在上海1 小时前
使用Java做URL短连接还原长链接获取参数
java·开发语言·程序人生·spring
爱吃烤鸡翅的酸菜鱼1 小时前
如何掌握【Java】 IO/NIO设计模式？工厂/适配器/装饰器/观察者模式全解析
java·开发语言·后端·设计模式·nio
鳳舞酒天1 小时前
Maven 下载和 Spring Boot 搭建
java·spring boot·maven
程序员大雄学编程1 小时前
「用Python来学微积分」17. 导数与导函数
开发语言·python·数学·微积分
扶尔魔ocy1 小时前
【QT常用技术讲解】可拖拽文件的Widget--QListWidget
开发语言·qt
热门推荐
01GitHub 镜像站点02UV安装并设置国内源03BongoCat - 跨平台键盘猫动画工具04GitLab 零基础入门指南：从安装到项目管理全流程05Linux下V2Ray安装配置指南06NVIDIA显卡驱动、CUDA、cuDNN 和 TensorRT 版本匹配指南07Labelme从安装到标注：零基础完整指南08安娜的档案(Anna’s Archive) 镜像网站/国内最新可访问入口（持续更新）09在VSCode配置Java开发环境的保姆级教程（适配各类AI编程IDE）10jdk21下载、安装（Windows、Linux、macOS）