初识c++（stack，queue）

已于 2024-08-11 11:15:45 修改
阅读量792 收藏 32
点赞数 31
文章标签： c++ java rpc
于 2024-08-09 16:07:34 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/suiyi_freely/article/details/141064573
版权

一、stack

1、基本接口

在这里插入图片描述

2、stcak模拟实现

从栈的接口中可以看出，栈实际是一种特殊的vector，因此使用vector完全可以模拟实现stack。

template<class T, class Con = deque<T>>
class stack
{
public:

    stack()
    {}

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

    void pop()
    {
        _c.push_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:
    Con _c;
};

二、queue

1、queue的使用

在这里插入图片描述

2、queue的模拟实现

因为queue的接口中存在头删和尾插，因此使用vector来封装效率太低，故可以借助list来模拟实

现queue，具体如下：

template<class T, class Con = deque<T>>
class queue
{
public:

    queue()
    {}
    void push(const T& x)
    {
        _c.push_back(x);
    }
    void pop()
    {
        _c.pop_front;
    }
    T& back()
    {
        _c.back();
    }
    const T& back()const
    {
        _c.back();
    }
    T& front()
    {
        _c.front();
    }
    const T& front()const
    {
        _c.front();
    }
    size_t size() const
    {
        return _c.size();
    }
    bool empty() const
    {
        return _c.empty();
    }
private:
    Con _c;
};

三、priority_queue

  1. 优先队列是一种容器适配器，根据严格的弱排序标准，它的第一个元素总是它所包含的元素

中最大的。

  1. 此上下文类似于堆，在堆中可以随时插入元素，并且只能检索最大堆元素(优先队列中位于顶

部的元素)。

  1. 优先队列被实现为容器适配器，容器适配器即将特定容器类封装作为其底层容器类，queue

提供一组特定的成员函数来访问其元素。元素从特定容器的“尾部”弹出，其称为优先队列的

顶部。

  1. 底层容器可以是任何标准容器类模板，也可以是其他特定设计的容器类。容器应该可以通过

随机访问迭代器访问，并支持以下操作：

​ empty()：检测容器是否为空

​ size()：返回容器中有效元素个数

​ front()：返回容器中第一个元素的引用

​ push_back()：在容器尾部插入元素

​ pop_back()：删除容器尾部元素

  1. 标准容器类vector和deque满足这些需求。默认情况下，如果没有为特定的priority_queue

类实例化指定容器类，则使用vector。

  1. 需要支持随机访问迭代器，以便始终在内部保持堆结构。容器适配器通过在需要时自动调用

算法函数make_heap、push_heap和pop_heap来自动完成此操作。

1、priority_queue的使用

优先级队列默认使用vector作为其底层存储数据的容器，在vector上又使用了堆算法将vector中

元素构造成堆的结构，因此priority_queue就是堆，所有需要用到堆的位置，都可以考虑使用

priority_queue。注意：默认情况下priority_queue是大堆。

在这里插入图片描述

#include <vector>
#include <queue>
#include <functional> // greater算法的头文件
void TestPriorityQueue()
{
	// 默认情况下，创建的是大堆，其底层按照小于号比较
	vector<int> v{ 3,2,7,6,0,4,1,9,8,5 };
	priority_queue<int> q1;
	for (auto& e : v)
		q1.push(e);
	cout << q1.top() << endl;
	// 如果要创建小堆，将第三个模板参数换成greater比较方式
	priority_queue<int, vector<int>, greater<int>> q2(v.begin(), v.end());
	cout << q2.top() << endl;
}

如果在priority_queue中放自定义类型的数据，用户需要在自定义类型中提供> 或者< 的重载。

class Date
{
public:
	Date(int year = 1900, int month = 1, int day = 1)
		: _year(year)
		, _month(month)
		, _day(day)
	{}
	bool operator<(const Date& d)const
	{
		return (_year < d._year) ||
			(_year == d._year && _month < d._month) ||
			(_year == d._year && _month == d._month && _day < d._day);
	}
	bool operator>(const Date& d)const
	{
		return (_year > d._year) ||
			(_year == d._year && _month > d._month) ||
			(_year == d._year && _month == d._month && _day > d._day);
	}
	friend ostream& operator<<(ostream& _cout, const Date& d)
	{
		_cout << d._year << "-" << d._month << "-" << d._day;
		return _cout;
	}
private:
	int _year;
	int _month;
	int _day;
};
void TestPriorityQueue()
{
	// 大堆，需要用户在自定义类型中提供<的重载
	priority_queue<Date> q1;
	q1.push(Date(2018, 10, 29));
	q1.push(Date(2018, 10, 28));
	q1.push(Date(2018, 10, 30));
	cout << q1.top() << endl;
	// 如果要创建小堆，需要用户提供>的重载
	priority_queue<Date, vector<Date>, greater<Date>> q2;
	q2.push(Date(2018, 10, 29));
	q2.push(Date(2018, 10, 28));
	q2.push(Date(2018, 10, 30));
	cout << q2.top() << endl;
}

2、模拟实现

#pragma once

#include<vector>
#include<list>
#include<functional>
using namespace std;
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 pq
{
	// 默认是大堆
	template<class T, class Container = vector<T>, class Compare = Less<T>>
	class priority_queue
	{
	public:
		//void AdjustUp(int child)
		//{
		//	Compare com;
		//	int parent = (child - 1) / 2;
		//	while (child > 0)
		//	{
		//		//if (_con[parent] < _con[child])
		//		if (com(_con[parent], _con[child]))
		//		{
		//			swap(_con[child], _con[parent]);
		//			child = parent;
		//			parent = (child - 1) / 2;
		//		}
		//		else
		//		{
		//			break;
		//		}
		//	}
		//}

		void push(const T& x)
		{
			_con.push_back(x);
			make_heap(_con.begin(), _con.end(), std::less<T>());//直接用算法库中的函数
			//AdjustUp(_con.size() - 1);
		}
		
		//void AdjustDown(int parent)
		//{
		//	// 先假设左孩子小
		//	size_t child = parent * 2 + 1;

		//	Compare com;
		//	while (child < _con.size())  // child >= n说明孩子不存在，调整到叶子了
		//	{
		//		// 找出小的那个孩子
		//		//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]))
		//		{
		//			swap(_con[child], _con[parent]);
		//			parent = child;
		//			child = parent * 2 + 1;
		//		}
		//		else
		//		{
		//			break;
		//		}
		//	}
		//}

		void pop()
		{
			swap(_con[0], _con[_con.size() - 1]);
			_con.pop_back();
			//AdjustDown(0);
			make_heap(_con.begin(), _con.end(), std::less<T>());//直接用算法库中的函数
		}

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

		size_t size() const
		{
			return _con.size();
		}

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

	private:
		Container _con;
	};
}

3、容器适配器

适配器是一种设计模式(设计模式是一套被反复使用的、多数人知晓的、经过分类编目的、代码设

计经验的总结)，该种模式是将一个类的接口转换成客户希望的另外一个接口。虽然stack和queue中

也可以存放元素，但在STL中并没有将其划分在容器的行列，而是将其称为容器适配器，这是因

为stack和队列只是对其他容器的接口进行了包装，STL中stack和queue默认使用deque，

四、deque

1、deque的原理介绍

deque(双端队列)：是一种双开口的"连续"空间的数据结构，双开口的含义是：可以在头尾两端

进行插入和删除操作，且时间复杂度为O(1)，与vector比较，头插效率高，不需要搬移元素；与

list比较，空间利用率比较高。

在这里插入图片描述

deque并不是真正连续的空间，而是由一段段连续的小空间拼接而成的，实际deque类似于一个

动态的二维数组，其底层结构如下图所示：

在这里插入图片描述

双端队列底层是一段假象的连续空间，实际是分段连续的，为了维护其“整体连续”以及随机访问

的假象，落在了deque的迭代器身上，因此deque的迭代器设计就比较复杂，如下图所示：

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

在这里插入图片描述

2、deque的缺陷

与vector比较，deque的优势是：头部插入和删除时，不需要搬移元素，效率特别高，而且在扩

容时，也不需要搬移大量的元素，因此其效率是必vector高的。

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

但是，deque有一个致命缺陷：不适合遍历，因为在遍历时，deque的迭代器要频繁的去检测其

是否移动到某段小空间的边界，导致效率低下，而序列式场景中，可能需要经常遍历，因此在实

际中，需要线性结构时，大多数情况下优先考虑vector和list，deque的应用并不多，而目前能看

到的一个应用就是，STL用其作为stack和queue的底层数据结构。

3、stack和list选择deque的原因

stack是一种后进先出的特殊线性数据结构，因此只要具有push_back()和pop_back()操作的线性

结构，都可以作为stack的底层容器，比如vector和list都可以；queue是先进先出的特殊线性数据

结构，只要具有push_back和pop_front操作的线性结构，都可以作为queue的底层容器，比如

list。但是STL中对stack和queue默认选择deque作为其底层容器，主要是因为：

  1. stack和queue不需要遍历(因此stack和queue没有迭代器)，只需要在固定的一端或者两端进

行操作。

  1. 在stack中元素增长时，deque比vector的效率高(扩容时不需要搬移大量数据)；queue中的

元素增长时，deque不仅效率高，而且内存使用率高。

的底层数据结构。**

3、stack和list选择deque的原因

stack是一种后进先出的特殊线性数据结构，因此只要具有push_back()和pop_back()操作的线性

结构，都可以作为stack的底层容器，比如vector和list都可以；queue是先进先出的特殊线性数据

结构，只要具有push_back和pop_front操作的线性结构，都可以作为queue的底层容器，比如

list。但是STL中对stack和queue默认选择deque作为其底层容器，主要是因为：

  1. stack和queue不需要遍历(因此stack和queue没有迭代器)，只需要在固定的一端或者两端进

行操作。

  1. 在stack中元素增长时，deque比vector的效率高(扩容时不需要搬移大量数据)；queue中的

元素增长时，deque不仅效率高，而且内存使用率高。

结合了deque的优点，而完美的避开了其缺陷。

suiyi_freely
关注
C++实现栈的初始化、进栈、出栈、清空、销毁、进制转换等操作
yy_1121的博客
04-07 1万+
C++实现栈的初始化、进栈、出栈、清空、销毁、进制转换等操作
7、deque容器及stack和queue容器
qq_42138448的博客
05-19 274
容器deque是一个(分段)连续空间，在表现上是连续，实际上是分段。deque的迭代器分别有四个指针，cur,first,last,node，node指针指向控制中心，即map（map的组成原理是vector数组）。当cur达到了first或last的时候(first和last表示这段空间的首尾)，通过map中的指针来指向下一段缓存区。start iterator是为了指明开始的一段缓存区 ，finish指向结束缓存区。接下来看一下deque源码（注意BufSiz）： 现列出deque的一个经...
C++||STL_STACK_QUEUE
HuiDiExAg的博客
08-24 171
STL_STACK_QUEUE 学习周报2 STACK and QUEUE 1.stack的介绍 1.stack是一种容器适配器，专门用在具有后进先出操作的上下文环境中，其删除只能从容器 的一端进行元素的插入与提取操作。 2.stack是作为容器适配器被实现的，容器适配器即是对特定类封装作为其底层的容器，并提 供一组特定的成员函数来访问其元素，将特定类作为其底层的，元素特定容器的尾部(即栈 顶)被压入和弹出。 3.stack的底层容器可以是任何标准的容器类模板或者一些其他特定的容器类，这些容器类应 该支持以
STL::deque以及由其实现的queue和stack
shayne000的博客
03-17 969
deque双向队列，可在头尾插入和删除。 存储方式：在内存中分段连续。 其iterator的功劳：当迭代器指到一个buffer的边界时会进行判断，有能力跳入下一个或者前一个buffer，形成连续的假象（模拟连续储存）。 GNU2.9 中deque模板含三个参数，允许指定buffer大小（GNU4.53以后不再允许） 第三个参数为缓冲区大小，默认值为0表示使用预设值，若为n(n!=0)则表示每个...
C++编程思想 第1卷 第6章 初始化和清除 带有构造函数和析构函数的Stack
eyetired的博客
07-21 243
带有构造和析构函数的链表 new和delete指针   //: C06:Stack3.h // From Thinking in C++, 2nd Edition // Available at http://www.BruceEckel.com // (c) Bruce Eckel 2000 // Copyright notice in Copyright.txt // With cons...
初识C++之模拟实现stack、queue和反向迭代器
Masquerena114514的博客
03-12 612
讲解了stl库中的stack和queue的模拟实现、适配器模式、双端队列及反向迭代器的实现和仿函数的概念
初识STL模版|c++基础--详细讲解
最新发布
署髫
08-04 690
STL（Standard Template Library）是C++的一部分，它是一个库，包含了几个组件，如向量、列表、映射、集合等。这些组件都是通用的，可以用于不同类型的数据，是一套非常好用且强大的C++模板。在C++中，你可以通过模板（templates）来创建自己的STL样式的数据结构。模板是C++中的一个特性，它允许你编写可以用于多种数据类型的代码。
C++STL之初识容器和迭代器
phosphenesvision的博客
07-05 245
提问大纲 初识STL 初识容器和迭代器 *表示这并不是一个问题，而是一些碎碎念 编译原理？预处理 编译 汇编 链接 memecpy函数？ 用C++定义数组的方法？自带的方法，动态分配内存，STL库 STL库有哪些版本？STL是开源的，不同的厂商基于此发展了泛型库，惠普HP STL，基于上述的SGI STL其中GCC编译器支持，基于上一个适配更多的编译器STLport，基于上三个PJ STL，非开源，适配vc++ gcc和g++？ *STL 容器 算法 迭代器 函数对象 适配器 内存分配器13个头文件，标准头
STL常用API(vector、list、deque、map、set、queue、stack、algorithm)
attitude_yu
07-15 1970
本文用于总结STL常用API！！！本文代码已经上传到github中。 1. STL(标准模板库) STL提供了一组表示容器、迭代器、函数对象和算法的组件。容器是用来存储若干个类型相同的值；迭代器用来遍历容器；函数对象是类似于函数的对象；算法是完成特定任务的方法。该库包含了诸多在计算机科学领域里所常用的基本数据结构和基本算法。 2. 容器的种类？ （本文图片来源于博客：https...
C++思维导图Xmind文件和.png文件（持续更新）
10-30
C++思维导图Xmind文件和.png文件： 构造函数与析构函数思维导图Xmind文件和.png文件 拷贝构造思维导图xmind文件...STL适配器——stack && queue STL——list C++——继承 C++——搜索二叉树 C++——AVL树 C++——红黑树
栈的初始化、进栈出栈、清空栈、销毁栈
03-17
栈的初始化、进栈出栈、清空栈、销毁栈，dos输入输出
C++初阶之stack和queue
qq_51604748的博客
05-17 673
queue的介绍队列是一种容器适配器，专门用于在FIFO上下文(先进先出)中操作，其中从容器一端插入元素，另一端 提取元素。队列作为容器适配器实现，容器适配器即将特定容器类封装作为其底层容器类，queue提供一组特定的 成员函数来访问其元素。元素从队尾入队列，从队头出队列。底层容器可以是标准容器类模板之一，也可以是其他专门设计的容器类。该底层容器应至少支持以下操作:empty：检测队列是否为空size：返回队列中有效元素的个数front：返回队头元素的引用。
【C++】stack栈基础使用
qq_44228301的博客
03-17 1586
C++中stack的基本用法
【栈】C++栈的建立、初始化、插入、删除
热门推荐
HiPricilla的博客
07-22 2万+
栈是限定在尾部进行插入或删除的线性表。表尾称为栈顶（top），表头称为栈底（base）。栈的修改按照后进先出的原则。 栈有两种存储表示方法：顺序栈和链栈。顺序栈是利用一组连续存储单元依次存放栈底到栈顶数据元素的位置。链栈是没有附加头结点的运算受限的单链表。栈顶指针就是链表的头指针。 注意： 1.如果在函数中需要修改形参，而且希望函数结束后变量修改生效，可以使用引用的方法。例如把栈顶元素传
Queue 和Stack 的区别
weixin_33918114的博客
07-06 134
protected void Page_Load(object sender, EventArgs e) { //queue 是队列，遵循先进先出的原则 //queue 属性 count // queue method Clear()　　　//清空　 ...
C++ STL学习之stack。
leiyifight的专栏
09-16 1101
stack 介绍 栈是一种容器适配器，特别为后入先出而设计的一种（LIFO ），那种数据被插入，然后再容器末端取出 栈实现了容器适配器，这是用了一个封装了的类作为他的特定容器，提供了一组成员函数去访问他的元素，元素从特定的容器，也就是堆栈的头取出袁术。 这个基础的容器可能是任何标准的容器类，和一些其他特殊设计的模板类，唯一的要求就是要支持一下的操作 [cpp] 
C++ [STL] stack用法详解
行到水穷处，坐看云起时。
07-21 498
C++ stack成员函数的用法详解
C++中stack的用法（超详细，入门必看）
H1727548的博客
05-25 2万+
【C++STL】之stack的用法。本文主要讲解了C++STL中的stack的定义及初始化和一些stack的常用用法。如果你觉得本文对你有所帮助的话，还望不吝惜您的三连支持一下我哦！
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

suiyi_freely

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值