【c++】——栈or队列or优先级队列

已于 2024-01-19 16:05:51 修改
阅读量1.2k 收藏 21
点赞数 32
分类专栏： c++ 文章标签： c++ 开发语言
于 2024-01-19 16:02:57 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_74438843/article/details/135695575
版权
本文介绍了C++STL中的三种容器适配器：Stack、Queue和Priority_Queue，包括它们的基本使用、底层实现以及仿函数在优先级队列中的应用。特别强调了Stack和Queue的特性，如Stack的后进先出和Queue的先进先出。
摘要由CSDN通过智能技术生成

目录

🎓容器适配器

🎓Stack栈

🚩Stack的介绍

🚩Stack的基本使用 

🚩Stack底层实现

🎓queue队列

🚩queue的介绍

🚩queue的基本使用

🚩queue的底层实现

🎓priority_queue优先级队列

🚩priority_queue的介绍

✅简单介绍一下仿函数

 🚩priority_queue的基本使用

🚩priority_queue的底层实现

✅仿函数的使用

🎓容器适配器

 容器适配器是一个封装了序列容器的一个类模板，它在一般的序列容器的基础上提供了一些不同的功能。之所以称为容器适配器，是因为它是适配容器来提供其它不一样的功能。通过对应的容器和成员函数来实现我们需要的功能。

        下面介绍了三个容器适配器：statk<T>,queue<T>,priority_queue<T>。

 注意：容器适配器都不存在迭代器。

        如果没有为stack,queue指定容器，默认使用deque作为默认容器。priority_queue容器默认使用vector作为默认容器。

🎓Stack栈

🚩Stack的介绍

以下是stack的成员函数 

string、vector、list都是容器,而stack和queue 是容器适配器,发现stack和queue都没有迭代器，因为stack要保证后进先出(LIFO)，queue要保证先进先出（FIFO）所以其实它们不需要迭代器。

🚩Stack的基本使用 

这下面是stack接口函数，使用是简单的，主要应用的场景。

#include <iostream>
using namespace std;
#include <stack>//记得包头文件
 
int main()
{
	stack<int> st;
	st.push(1);
	st.push(2);
	st.push(3);
	st.push(4);
	st.push(5);
	st.push(6);
	while (!st.empty())
	{
		cout << st.top() << " ";
		st.pop();
	}
	cout << endl;
	return 0;
}

🚩Stack底层实现

stack就是我们数据结构学的栈，是一种操作受限制的线性表，所以它可以用链表实现，也可以用顺序表（数组）实现，不过当时C语言只实现了数组栈，因为相对而言数组的结构实现更优一些。因为数组在尾上插入删除数据的代价比较小。那传统的写法就是用一个数组或链表去写.若按C++STL库里的方式来写，就可以用适配器（配接器）模式来实现。

#pragma once
#include<vector>
#include<list>
#include<deque>

namespace cl {
	template<class T,class Container=deque<T>>//Container缺省用deque容器
	class stack {
	public:
		stack() {}
		void push(const T& x) { _c.push_back(x); }
		void pop() { _c.pop_back(); }
		T& top() { return _c.back(); }
		const T& top()const { return _c.back(); }
		size_t size()const { return _c.size(); }
		bool empty()const { return _c.empty(); }
	private:
		Container _c;
	};

	void test_stack1()
	{
		//stack<int>st;
		stack<int, vector<int>>st;//明确给出用vector容器
		st.push(1);
		st.push(2);
		st.push(3);
		st.push(4);
		while (!st.empty())
		{
			cout << st.top() << " ";
			st.pop();
		}
		cout << endl;
	}
	void test_stack2()
	{
		stack<int, list<int>>st;//明确给出用list容器
		st.push(1);
		st.push(2);
		st.push(3);
		st.push(4);
		while (!st.empty())
		{
			cout << st.top() << " ";
			st.pop();
		}
		cout << endl;
	}
}

🎓queue队列

🚩queue的介绍

元素从队尾入队列，从对头出队列。

🚩queue的基本使用

这下面是queue接口函数，使用是简单的，主要应用的场景。

使用queue需要包含头文件#include<queue>，queue容器适配器没有迭代器

int main()
{
	queue<int>q;
	q.push(1);
	q.push(2);
	q.push(3);
	q.push(4);
	cout << q.front() << endl;//队头元素
	cout << q.back() << endl;//队尾元素
	cout << q.size() << endl;//队长
	while (!q.empty())
	{
		cout << q.front() << " ";
		q.pop();
	}
	return 0;
}

🚩queue的底层实现

因为queue存在头删和尾插，因此使用vector容器来封装效率太低，头删需要挪动数据，并且vector并没有提供pop_front(),因为效率太低。

#pragma once
#include<queue>
#include<list>
namespace cl {
	template <class T,class Container=deque<T>>
	class queue {
	public:
		queue(){}
		void push(const T& x) { _c.push_back(x); }//尾插
		void pop() { _c.pop_front(); }//头删
		T& back() { return _c.back(); }//队尾值
		const T& back()const { return _c.back(); }//取队尾值
		T& front() { return _c.front(); }//队头值
		const T& front()const { return _c.front(); }//取队头值
		size_t size()const { return _c.size(); }//队长
		bool empty()const { return _c.empty(); }//判空

	private:
		Container _c;
	};

	void test_queue()
	{
		queue<int>q;
		q.push(1);
		q.push(2);
		q.push(3);
		q.push(4);
		while (!q.empty())
		{
			cout << q.front() << " ";
			q.pop();
		}
		cout << endl;
	}

	void test_queue2()
	{
		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();
		}
		cout << endl;
	}
}

🎓priority_queue优先级队列

🚩priority_queue的介绍

默认形成大堆。优先队列使用仿函数来控制生成大根堆还是生成小根堆。

✅简单介绍一下仿函数

 仿函数（Functor）又称为函数对象（Function Object）是一个能行使函数功能的类。仿函数的语法几乎和我们普通的函数调用一样，不过作为仿函数的类，都必须重载 operator() 运算符。因为调用仿函数，实际上就是通过类对象调用重载后的 operator() 运算符。仿函数是一个类，只是使用起来像函数。等下模拟实现时就知道了。

 🚩priority_queue的基本使用

优先队列默认使用vector作为存储数据的容器，在容器的基础上使用堆算法，将vector中的元素调整成一个堆结构。

注意：优先队列就是一个堆，在使用堆的地方都可以使用优先队列。默认生成大根堆，头文件也是#include<queue>

//默认调整大堆
int main()
{
	priority_queue<int>pq;
	pq.push(1);
	pq.push(2);
	pq.push(5);
	pq.push(3);
	pq.push(0);
	while (!pq.empty())
	{
		cout << pq.top() << " ";
		pq.pop();
	}
	cout << endl;
	return 0;
}

//小堆
int main()
{
	priority_queue<int,vector<int>,greater<int>>pq;
	pq.push(1);
	pq.push(2);
	pq.push(5);
	pq.push(3);
	pq.push(0);
	while (!pq.empty())
	{
		cout << pq.top() << " ";
		pq.pop();
	}
	cout << endl;
	return 0;
}

🚩priority_queue的底层实现

   回顾一下堆的插入与删除操作。

  •         堆的插入：在堆尾插入数据，再向上调整成堆。
  •         堆的删除：将堆顶元素和对尾元素交换，再向下调整成堆。

#pragma once
#include<vector>
#include<deque>
namespace cl {
	template <class T,class Container=vector<T>>
	class priority_queue {
		void AdjustDown(int parent)
		{
			int child = parent * 2 + 1;
			while (child < _con.size())
			{
				if (child + 1 < _con.size() && _con[child] < _con[child + 1])
				{
					child++;
				}
				if (_con[parent] < _con[child])
				{
					swap(_con[parent], _con[child]);
					parent = child;
					child = parent * 2 + 1;
				}
				else
				{
					break;
				}
			}
		}
		void Adjustup(int child)
		{
			int parent = (child - 1) / 2;
			while (child >0)
			{
				if (_con[parent]<_con[child])
				{
					swap(_con[parent], _con[child]);
					child = parent;
					parent = (child - 1) / 2;
				}
				else
				{
					break;
				}
			}
		}


	public:
		priority_queue() {}
		template <class InputIterator>
		priority_queue(InputIterator first, InputIterator last)
		{
			while (first != last)
			{
				_con.push_back(*first);
				++first;
			}
			//建堆
			for (int i = (_con.size - 1 - 1) / 2; i >= 0; i--)
			{
				AdjustDown(i);
			}
		}
		bool empty() {
			return _con.empty();
		}
		size_t size() {
			return _con.size();
		}
		T& top() {
			return _con.front();
		}
		const T& top()const {
			return _con.front();
		}
		void push(const T& val) {
			_con.push_back(val);
			Adjustup(_con.size() - 1);
		}
		void pop() {
			swap(_con[0], _con[_con.size() - 1]);
			//少一个元素是size减减，交换后，直接删除最后一个元素
			_con.pop_back();
			AdjustDown(0);
		}

	private:
		Container _con;
	};

	void priority_queue1()
	{
		priority_queue<int>pq;
		pq.push(1);
		pq.push(3);
		pq.push(4);
		pq.push(5);
		while(!pq.empty())
		{
			cout << pq.top() << " ";
			pq.pop();
		}
		cout << endl;
	}
}

✅仿函数的使用

仿函数：优先队列通过仿函数来实现建立大根堆还是小根堆。

调整建立大根堆还是小根堆，只需要改变调整函数。父亲结点与孩子结点比较时的大于小于号。怎么通过仿函数来实现呢？

调整函数如何修改

#pragma once
#include<vector>
#include<deque>
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 cl {
	template <class T,class Container=vector<T>,class Compare=Less<T>>
	class priority_queue {
		void AdjustDown(int parent)
		{
			Compare com;
			int child = parent * 2 + 1;
			while (child < _con.size())
			{
				if (child + 1 < _con.size() && 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;
				}
			}
		}
		void Adjustup(int child)
		{
			Compare com;
			int parent = (child - 1) / 2;
			while (child >0)
			{
				if (com(_con[parent],_con[child]))
				{
					swap(_con[parent], _con[child]);
					child = parent;
					parent = (child - 1) / 2;
				}
				else
				{
					break;
				}
			}
		}


	public:
		priority_queue() {}
		template <class InputIterator>
		priority_queue(InputIterator first, InputIterator last)
		{
			while (first != last)
			{
				_con.push_back(*first);
				++first;
			}
			//建堆
			for (int i = (_con.size - 1 - 1) / 2; i >= 0; i--)
			{
				AdjustDown(i);
			}
		}
		bool empty() {
			return _con.empty();
		}
		size_t size() {
			return _con.size();
		}
		T& top() {
			return _con.front();
		}
		const T& top()const {
			return _con.front();
		}
		void push(const T& val) {
			_con.push_back(val);
			Adjustup(_con.size() - 1);
		}
		void pop() {
			swap(_con[0], _con[_con.size() - 1]);
			//少一个元素是size减减，交换后，直接删除最后一个元素
			_con.pop_back();
			AdjustDown(0);
		}

	private:
		Container _con;
	};

	void priority_queue1()
	{
		priority_queue<int>pq;//默认调成大根堆
		pq.push(1);
		pq.push(3);
		pq.push(4);
		pq.push(5);
		while(!pq.empty())
		{
			cout << pq.top() << " ";
			pq.pop();
		}
		cout << endl;


		priority_queue<int, vector<int>, greater<int>> pq2;//小根堆
		pq2.push(1);
		pq2.push(3);
		pq2.push(4);
		pq2.push(5);
		while (!pq2.empty())
		{
			cout << pq2.top() << " ";
			pq2.pop();
		}
		cout << endl;
	}
}

一帆风顺不现实，祝你挫折少一点。

chlorine5
关注
  • 32
    点赞
  • 踩
  • 21
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C++STL容器之priority_queue
Jerry_qbw的博客
07-26 1261
观察这两张图片，他们都是二叉树，若果观察的仔细，能看出他们是完全二叉树。左图中，根节点是所有元素中最大的，右图中则恰好相反。左图每个节点都比他的左右子节点大，有图每个节点都比他的左右子节点小，这就是堆结构。堆是具有下列性质的完全二叉树每个节点的值都大于或等于其左右子节点的值，称为大顶堆，相反则为小顶堆从堆的定义得知，根节点一定是其中最大（小）的一个，较大（小）的节点越靠近根节点（不绝对是这样）优先队列使用的数据结构为二叉堆。...
C/C++ 关于逻辑运算符and、or、not的使用
wendyWJGU的博客
11-30 2166
C/C++ 关于逻辑运算符and、or、not的使用
c++ priority_queue用法
bieliwuguiqi的博客
04-28 327
priority_queue
C/C++中的and、or、not
old__tree的博客
05-28 7430
​and、or、not是c++中的关键字，但不是c的。 C++中的​and、or、not是&&、||、!的备胎，这个原因是在以前一些机器不支持iso646编码（即无法输入&&、||、!），所以使用and、or、not。除此以外，这还和编译器相关，VS2017不支持，不过好像可以通过设置支持（可以自行查询）。 在C中若想使用and、or、not，可以添加头文件<iso646.h>，其是通过宏定义实现的。 ...
C++ 支持and 和 or
Eros__L的博客
08-05 1408
今天写C++项目时，由于之前用python帮同事写了个脚本，不小心将&&习惯的写成and，然后送git上review时被打回来了，当时就惊了，为啥没报错？我还特意去用codeblocks敲了一下，然后去查了一下，发现是C++11的新特性，C++的语法越来越友好了哈哈。。 #include <bits/stdc++.h> using namespace std; int main() { int a=1,b=2,c=0; if(a and b) .
栈和队列从小白到入门的学习路径
最新发布
04-03
- **优先级队列（Priority Queue）**：元素按照优先级进行出队，而非简单的FIFO原则，常用于调度和搜索算法。 **5. 实现方式** 栈和队列可以使用数组或链表来实现。数组实现简单，但插入和删除操作可能涉及大量...
用C++实现队列的程序代码
12-26
C++实现队列，如有不足之处，还望指正 代码如下:// MyQueue.cpp : 定义控制台应用程序的入口点。//实现链式队列（queue），包括一个头结点。队列操作包括在队头出队（pop）、在队尾入队（push）、//取得队头元素...
C++ 中”priority_queue” 优先级队列实例详解
12-31
C++ 中”priority_queue” 优先级队列实例详解 1. 简介 标准库队列使用了先进先出(FIFO)的存储和检索策略. 进入队列的对象被放置在尾部, 下一个被取出的元素则取自队列的首部. 标准库提供了两种风格的队列: FIFO ...
优先级队列的C++实现
06-03
在C++标准库中，`<queue>`和`<priority_queue>`头文件提供了对队列和优先级队列的支持。在本讨论中，我们将深入探讨C++如何实现优先级队列，并结合“服务器应用”这一标签来理解其在实际问题中的应用。 首先，C++的...
优先级队列测试程序c++
07-13
优先级队列测试程序c++
C++ 仿函数or函数对象
二进制君
12-27 670
文章目录1、概念2、实际应用 1、概念 重载函数调用操作符的类，其对象常称为函数对象（function object），即它们是行为类似函数的对象，也叫仿函数(functor)，其实就是重载“()”操作符，使得类对象可以像函数那样调用。 注意: 1.函数对象(仿函数)是一个类，不是一个函数。 2.函数对象(仿函数)重载了”() ”操作符使得它可以像函数一样调用。 假定某个类有一个重载的 operator()，而且重载的 operator()要求获取一个参数，我们就将这个类称为“一元仿函数”（unary
c++ 优先队列(priority_queue)
我走的每一步都算数
11-10 8290
优先队列的本质是堆，但它具有队列的所有操作特性，与普通队列不同的地方就是出队的时候按照优先级顺序出队，这个优先级即最大堆或最小堆的规则（即大的为top优先出队或小的为top优先出队），在队列的基础上加了个堆排序。以O(log n) 的效率查找一个队列中的最大值或者最小值，其中是最大值还是最小值是根据创建的优先队列的性质来决定的。
【转载】C/C++ 代用运算符表示：and、or、not...
专注于C/C++/Linux领域创作
03-18 3708
C++（及 C）源代码可以用任何包含 ISO 646:1983 不变字符集的非 ASCII 7 位字符集书写。然而，一些 C++ 运算符及标点要求 ISO 646 编码集外的字符：{, }、[, ]、#、\、^、|、~。为了能够使用不存在一些或全部这些符号的字符编码（例如德语 DIN 66003），C++ 定义下列由 ISO 646 兼容字符组成的代用写法。
C++——优先级队列(priority_queue)的使用及实现
热门推荐
weixin_47257473的博客
03-02 2万+
我们之前讲过数据结构中的队列，它具有先进先出的特性（FIFO）.添加元素时只能在队尾插入，删除元素时只能删除队首的元素而优先级队列，它并不满足先进先出的特性，倒像是数据结构中的“堆”.优先级队列每次出队时只能是队列中优先级最高的元素而不是队首的元素。这个优先级可以通过元素的大小，或者赋值运算符重载等进行比较例如定义元素越大，优先级越高，那么每次出队的时候一定是队列中最大的元素，因为它的优先级最高.并且重新进行维护.经过上述的说明，是不是和我们所说的“堆”很相似，优先级队列的内部确实是由堆结构实现.
C++-queue头文件-队列常用函数-#include＜queue＞新手入门
KIDaptx4869的博客
07-20 1万+
在front，即队头，允许删除操作，进行出列操作，在rear，即队尾，允许插入操作，进行入列操作。在建立的队列q中压入5,10，15，三个整型数据，此时队列按照先进先出的原则，pop出队首的数据后，此时队列队首的数据应为10。在建立的队列q中压入5,10，15，三个整型数据，此时队列按照先进先出的原则，队首的数据应为5。在未压入数据时，此时列表q为空，true，输出为1，当压入数据后，列表不为空，输出为0.队列为空时，q的size为0，当压入三个数据之后，队列的size为3.队尾的数据应为15。...
C++中 queue 、 deque、priority_queue详解
qq_22613757的博客
11-15 1562
最近看到一道题用到了队列，在这里就具体的分析一下C++中的这三种队列的区别 queue 用法： #include &lt;iostream&gt; #include &lt;queue&gt; using namespace std; int main() { queue&lt;int&gt; myQueue; cout &lt;&lt; myQueue.empty() &lt...
C++优先队列（priority_queue）
weixin_52192405的博客
05-05 1万+
又是通过算法题来学习C++的一天
转载C++如何进阶学习
sesiria的博客
10-24 8388
C只读一本书《 The C Proguamming Language 》 读读C之父的著作，抛开老谭写的那本； C++你可以读《C++ primer》，其实当你把这两本书读通后，我想对于C/C++语言的经验（除此之外要积累项目经验）来讲找工作是一定没问题的，可能还会比很多工作了的程序员在语言方面基础好。 如果想精通，结合我自己的体会，建议在C++方面阅读《effecti
C、C++orJAVA
playoffs的专栏
02-22 836
大学本科也上过c和c++的课程，但是练的很少。现在用他们写一个小的程序估计也有很多问题。如今，在读研究生，老师又要求用java，这个说是会一些，java的精髓却不知一二。回头看这几年走过的路，实在有太多感触。至今没有一门语言学的特别优秀，到时工作都成问题。自己俨然是菜鸟一个，多少次希望有所改变，而每次都因为这样那样的借口使我变得如此轻薄。现在看来，知道这么多真是一个看似美丽的错误。计划要学
C++优先级队列实现与应用详解
- STL中的`priority_queue`：C++标准库提供的现成优先级队列实现，支持自定义比较函数来指定优先级。 - 排队系统模拟：优先级队列在模拟现实世界场景如事件驱动的系统和调度问题中有广泛应用。 - 应用场景举例： - ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值