【CPP】栈、双端队列、队列、优先级队列与反向迭代器

已于 2024-08-12 19:47:43 修改
阅读量863 收藏 11
点赞数 19
分类专栏： C++专栏 文章标签： 适配器模式 CPP 栈 队列
于 2024-08-11 17:51:29 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2302_79031646/article/details/141108570
版权

关于我：在这里插入图片描述


睡觉待开机：个人主页

个人专栏: 《优选算法》《C语言》《CPP》
生活的理想，就是为了理想的生活!
作者留言

PDF版免费提供：倘若有需要，想拿我写的博客进行学习和交流，可以私信我将免费提供PDF版。
留下你的建议：倘若你发现本文中的内容和配图有任何错误或改进建议，请直接评论或者私信。
倡导提问与交流：关于本文任何不明之处，请及时评论和私信，看到即回复。

参考目录

1.前言

栈与队列，是我们平常经常用到的数据结构之一，尤其做题的时候会经常用到。那栈是怎么实现的？为什么这么实现？本文将简单回答并整理。

2.栈

2.1栈的简介

栈 是一种 特殊的线性表，具有数据 先进后出 特点。
在这里插入图片描述

CPP库参考文档：stl_stack

栈提供了常见的几个接口：push\pop\top\size\empty

2.2栈接口的认识

construct

在这里插入图片描述

//可以构造一个空的stack
stack<int> s;

//可以先构造一个deque，再将其值赋值给sv进行构造
deque<int> v(6, 6);
stack<int> sv(v);
while (!sv.empty())
{
	cout << sv.top() << " ";
	sv.pop();
}//6 6 6 6 6 6
cout << endl;

swap

在这里插入图片描述

stack<int> s1;//空的栈
deque<int> v(6, 6);
stack<int> s2(v);//有内容的栈
s2.swap(s1);
cout << "this is s1" << ":" << endl;
while (!s1.empty())
{
	cout << s1.top() << " ";
	s1.pop();
}
cout << endl;

cout << "this is s2" << ":" << endl;
while (!s2.empty())
{
	cout << s2.top() << " ";
	s2.pop();
}
cout << endl;
/*this is s1:
6 6 6 6 6 6
this is s2:*/

栈中的迭代器在哪？

栈作为一种容器，是没有迭代器的。之所以不提供迭代器，因为迭代器具有随机访问的功能，这会打破栈先进后出的特性。

2.3栈的简化模拟实现

#pragma once
#include<vector>
#include<iostream>

using namespace std;
namespace szg
{
    template<class T, class Container = vector<T>>
    class stack
    {
    private:
        Container _st;
    public:
        void push_back(const T& num)
        {
            _st.push_back(num);
        }

        void pop_back()
        {
            _st.pop_back();
        }

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

        size_t size()
        {
            return _st.size();
        }

        const T& top()
        {
            return _st.back();
        }
    };
}

2.4适配器模式

适配器模式是指软件开发中的一种经典设计模式，适配器模式是一种将一个类的接口转换成客户希望的另外一个接口的设计模式。由于其转变方便，而受到软件设计者们的喜爱，在上文模拟stack的过程中，template<class T, class Container = vector<T>>的container就充当了适配器的角色。

实际开发：
在实际开发过程中，我们经常遇到这样的事情，我们根据初步的需求制定了一个基类，在开发过程中才了解到详细的需求或者需求发生了变动。而开发工作中的接口早已经定义完毕，并已经大规模投入编码。此时若改动接口的定义会造成很多编码上重复性的修改工作，并进而有可能造成修改不完全而导致的语义错误或逻辑错误。语义错误尚可以在编译阶段发现，而一旦发生逻辑性的错误，后果将会非常严重，甚至足以导致系统崩溃。此时就需要用到适配器模式的设计方法。

主要应用：
适配器模式主要应用于，当接口里定义的方法无法满足客户的需求，或者说接口里定义的方法的名称或者方法界面与客户需求有冲突的情况。

两类模式：

  • 对象适配器模式 - 在这种适配器模式中，适配器容纳一个它我包裹的类的实例。在这种情况下，适配器调用被包裹对象的物理实体。
  • 类适配器模式 - 这种适配器模式下，适配器继承自已实现的类（一般多重继承）。

既然说到适配器这个话题，我们简单来介绍一下STL库中最常用的适配器——deque

3.deque双端队列

deque虽然叫做双端队列，但实在是跟队列没什么关系，甚至说底层完全不是队列。deque是STL中的容器之一，是经典的适配器容器，他被创作出来最重要的应用场景就是做类适配器而存在。

deque是一种“全面发展”容器选手，融合了vector和list的特性。

3.1deque的特性

之所以说deque是一种融合vector和list的特性，是因为deque的特性：
在这里插入图片描述
除此之外，他不但支持vector的[]随机访问，还支持list的头插头删效率很高的特点。

可谓是“能文能武”，这么“全能”的deque底层结构是如何的呢？

3.2deque的内部构造

在这里插入图片描述
deque的内部控制是依靠迭代器实现的。
在这里插入图片描述

● cur是指向当前的访问元素
● first是指向当前buff的开始元素
● end是指向当前buff的末尾元素的下一个地址
● node是指向当前buff在中控数组中存放的位置

3.3deque的操作逻辑

deque的插入和删除，效率很高：
deque的头插尾插效率是挺高的。这是因为尾插一个元素后，迭代器会看看中控数组最后一个buff是否还有空间，如果有则尾插到最后一个buff，如果没有就新开一个buff插入。头插一个元素，他会现在中控数组的头部开一个buff，因为默认是从中控数组中间开始新增的，所以可以支持常数时间开空间，之后同尾插同理。
在这里插入图片描述
在这里插入图片描述
中间插入插入元素处理比较麻烦
deque中间插入有两种设计，

  • 如果中间插入元素后面所有元素都往后挪动一位，效率比较低在这里插入图片描述
  • 如果中间插入元素改变buff的大小，那么上面[]访问规则就不适用，会很麻烦。在这里插入图片描述
    deque的元素[]访问计算规则，且[]访问效率一般
    一般情况下，buff每个都是相同大小并且没有头插新元素时候，下标访问可以采用
    ● 先找是第几个buff，n/buff.size()
    ● 在确定是这个buff中的第几个元素，n%buff.size()
    但是如果有头插元素，首先应该减去第一个buff元素的个数，然后在进行上面步骤。
    ● n-=buff1.size()
void test_op1()
{
	srand(time(0));
	const int N = 1000000;

	deque<int> dq;
	vector<int> v;

	for (int i = 0; i < N; ++i)
	{
		auto e = rand() + i;
		v.push_back(e);
		dq.push_back(e);
	}

	int begin1 = clock();
	sort(v.begin(), v.end());
	int end1 = clock();

	int begin2 = clock();
	sort(dq.begin(), dq.end());
	int end2 = clock();

	printf("vector:%d\n", end1 - begin1);
	printf("deque:%d\n", end2 - begin2);
}
//vector:259
//deque:1263

void test_op2()
{
	srand(time(0));
	const int N = 1000000;

	deque<int> dq1;
	deque<int> dq2;

	for (int i = 0; i < N; ++i)
	{
		auto e = rand() + i;
		dq1.push_back(e);
		dq2.push_back(e);
	}

	int begin1 = clock();
	sort(dq1.begin(), dq1.end());
	int end1 = clock();

	int begin2 = clock();
	// 拷贝到vector
	vector<int> v(dq2.begin(), dq2.end());
	sort(v.begin(), v.end());
	dq2.assign(v.begin(), v.end());
	int end2 = clock();

	printf("deque sort:%d\n", end1 - begin1);
	printf("deque copy vector sort, copy back deque:%d\n", end2 - begin2);
}
//deque sort : 1345
//deque copy vector sort, copy back deque : 358

经过上面分析之后，也许你就会发现deque是挺“全能”的，也挺“全不能”的：

  • 在方括号随机访问上，他比不上vector方括号访问的极致效率
  • 在中间插入删除元素时候，又比不上list中间插入删除的极致效率

3.4deque作为stack/queue适配器的优先性？

为什么CPP库中选择deque作为stack/queue的适配器呢？
因为stack和queue都只会用到头插尾插头删尾删，恰好deque头尾插删效率都很好。也可以说，deque就是专门为stack/queue适配专门设计的一个容器。

4.队列queue

queue 是队列的含义，其特点是保证了数据先进先出，后进后出的特点，底层可以用vector、list或deque进行适配。

在这里插入图片描述

4.1队列的重要接口

与栈不同，队列提供了下面几个接口：
在这里插入图片描述
这里不再过多赘述。

4.2队列的简单模拟实现

#define _CRT_SECURE_NO_WARNINGS 1
#include<deque>

namespace szg
{
	template<class T, class Container = std::deque<T>>
	class queue
	{
	private:
		Container _con;

	public:
		size_t size()
		{
			return _con.size();
		}

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

		T& front()
		{
			return _con.front();
		}

		T& back()
		{
			return _con.back();
		}

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

		void pop()
		{
			_con.pop_front();
		}
	};
}

#define _CRT_SECURE_NO_WARNINGS 1
#include"Queue.h"
#include<iostream>

int main()
{
	szg::queue<int> q;
	for (int i = 0; i < 100; i++)
	{
		q.push(i);
	}
	while (!q.empty())
	{
		std::cout << q.front() << " ";
		q.pop();
	}
	std::cout << std::endl;
	//0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99

	return 0;
}

4.3队列与栈的异同

队列与栈的差异重点在于相同序列进入容器，出数据会有所不同。
在这里插入图片描述

5.priority_queue优先级队列 -> 堆

5.1简单介绍

在这里插入图片描述

优先级队列不是队列，是一种容器适配器，底层是大堆。
在优先级队列提供了一些接口允许公开调用：
在这里插入图片描述

5.2简单使用

// 优先级队列，默认底层是大堆。
priority_queue<int> ps;
ps.push(2);
ps.push(3);
ps.push(4);
ps.push(1);

while (!ps.empty())
{
	cout << ps.top() << " ";
	ps.pop();
}//4 3 2 1

在这里插入图片描述
那可以让他变成小堆吗？当然可以。

// 优先级队列，可以用仿函数置为小堆
priority_queue<int, vector<int>, greater<int>> pq;
pq.push(2);
pq.push(3);
pq.push(4);
pq.push(1);

while (!pq.empty())
{
	cout << pq.top() << " ";
	pq.pop();
}//1 2 3 4

在这里插入图片描述

// 我们发现sort默认排序为升序。
vector<int> v = { 1,3,4,2 };
vector<int>::iterator it = v.begin();
while (it != v.end())
{
	cout << *it << " ";
	it++;
}//1 3 4 2
cout << endl;

sort(v.begin(), v.end());
it = v.begin();
while (it != v.end())
{
	cout << *it << " ";
	it++;
}//1 2 3 4

为了让sort变成升序，我们也可以用仿函数进行设置。

vector<int> v = { 1,3,4,2 };
vector<int>::iterator it = v.begin();
while (it != v.end())
{
	cout << *it << " ";
	it++;
}//1 3 4 2
cout << endl;

sort(v.begin(), v.end(), greater<int>());
it = v.begin();
while (it != v.end())
{
	cout << *it << " ";
	it++;
}//4 3 2 1

这里需要重点区分的是：

priority_queue<int, vector<int>, greater<int>> pq;
sort(v.begin(), v.end(), greater<int>());

我们发现两个greater一个带括号一个不带，这是什么情况呢？
模板参数与函数参数的需要
要注意优先级队列是一种模板，需要的是类型进行实例化，而sort是模板实例化出来的一种函数，需要迭代器区间和具体的比较仿函数对象，而不是仅仅一个仿函数类型就行。

既然上面用到了仿函数，下面进行简单介绍。

5.3仿函数

仿函数：也称函数对象，仿函数是一种特殊的对象！他的对象可以像函数一样去使用。
下面进行举例：

//仿函数类
struct Less
{
public:
	bool operator()(const int& x, const int& y)
	{
		return x < y;
	}
};

void Test()
{
	Less lessfunc;
	cout << lessfunc(5,6) << endl; // 结果：1

这里需要注意哈，上面的数字5和6作为参数传递给operator()，如果要用引用来接收，必须前面加上const，因为这是引用常量值。

//仿函数类
struct Less
{
public:
	bool operator()(const int& x, const int& y)
	{
		return x < y;
	}
};

void Test()
{
	Less lessfunc;
	cout << lessfunc(5,6) << endl;//1

	vector<int> v = { 1,3,4,2 };
	vector<int>::iterator it = v.begin();
	while (it != v.end())
	{
		cout << *it << " ";
		it++;
	}//1 3 4 2
	cout << endl;

	sort(v.begin(), v.end(), lessfunc);
	it = v.begin();
	while (it != v.end())
	{
		cout << *it << " ";
		it++;
	}//1 2 3 4
}

然后上面的仿函数类可以加上模板的语法，们用的 greater<int> 差不多了。

//仿函数类
template<typename T>
struct Less
{
public:
	bool operator()(const T& x, const T& y)
	{
		return x < y;
	}
};

void Test()
{
	vector<int> v = { 1,3,4,2 };
	vector<int>::iterator it = v.begin();
	while (it != v.end())
	{
		cout << *it << " ";
		it++;
	}
	cout << endl;

	sort(v.begin(), v.end(), Less<int>());
	it = v.begin();
	while (it != v.end())
	{
		cout << *it << " ";
		it++;
	}
}

5.4优先级队列模拟实现

#pragma once
#include<vector>
#include<iostream>
using namespace std;

template<typename T>
struct Less
{
public:
	bool operator()(const T& x, const T& y)
	{
		return x < y;
	}
};

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

template<class T, class Container = vector<T>, class Compare = Greater<T>>
class periority_queue
{
private:
	Container _con;
public:
	void adjust_up(int child)
	{
		Compare com;
		int parent = (child - 1) / 2;

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

	void push(const T& x)
	{
		_con.push_back(x);
		adjust_up(_con.size() - 1);
	}

	void adjust_down(int parent)
	{
		Compare com;
		int child = parent * 2 + 1;
		while (child < _con.size())
		{
			if (child + 1 < _con.size() && com(_con[child + 1], _con[child]))
			{
				child = child + 1;
			}

			if (com(_con[child], _con[parent]))
			{
				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();
		adjust_down(0);
	}

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

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

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

//指针模板
template<class T>
struct GreaterPDate
{
	bool operator()(const T& d1, const T& d2)
	{
		return *d1 > *d2;
	}
};

void test_priority_queue2()
{
	priority_queue<Date*, vector<Date*>, GreaterPDate<Date*>> pqptr;
	Date d1(2024, 4, 14);
	Date d2(2024, 4, 11);
	Date d3(2024, 5, 15);
	pqptr.push(&d1);
	pqptr.push(&d2);
	pqptr.push(&d3);

	while (!pqptr.empty())
	{
		cout << *(pqptr.top()) << " ";
		pqptr.pop();
	}
	cout << endl;
}

6.反向迭代器

6.1简单介绍

下面我用库函数来进行一个简单演示。
在这里插入图片描述

std::list<int> l = { 1,2,3,4,5,6 };
std::list<int>::reverse_iterator rit = l.rbegin();
while (rit != l.rend())
{
	std::cout << *rit << " ";
	++rit;
}//6 5 4 3 2 1
std::cout << std::endl;

6.2反向迭代器的设计思路

  1. 思路1：我们可以像前面实现const迭代器一样写一个类，显然，这样我们即使写模板也需要针对不同的容器进行写不同的反向迭代器。
  2. 思路2：封装iterator，然后重载其部分运算符。
    下面来重点介绍第二种思路的实现方式：
    在这里插入图片描述
    这样的好处是，我们只需要设计一个反向迭代器类，就可以根据不同的正向迭代器自由变换其反向迭代器。

6.3反向迭代器的模拟实现

#define _CRT_SECURE_NO_WARNINGS 1


namespace szg
{
	template<class Tterator, class Ref, class Ptr>
	class ReverseIterator
	{
	private:
		Tterator _it;
	public:
		typedef ReverseIterator<Tterator, Ref, Ptr> Self;
		//构造函数
		ReverseIterator(Tterator it)
			:_it(it)
		{}

		//解引用
		Ref operator*()
		{
			Tterator temp = _it;
			temp--;

			return *temp;
		}

		//->函数
		Ptr operator->()
		{
			return &(this->operator*());
		}

		//前置++
		Self& operator++()
		{
			--_it;

			return *this;
		}
		
		//前置--
		Self& operator--()
		{
			++_it;

			return *this;
		}

		//!=函数重载
		bool operator!=(const Self& s)
		{
			return _it != s._it;
		}
	};
}

#include"List.h"
#include<list>

void test()
{
	szg::list<int> l = { 1, 2, 3, 4, 5, 6 };
	/*l.push_back(1);
	l.push_back(2);
	l.push_back(3);
	l.push_back(4);
	l.push_back(5);
	l.push_back(6);*/

	szg::list<int>::reverse_iterator rit = l.rbegin();
	while (rit != l.rend())
	{
		std::cout << *rit << " ";
		++rit;
	}//6 5 4 3 2 1
	std::cout << std::endl;
}

int main()
{
	//std::list<int> l = { 1,2,3,4,5,6 };
	//std::list<int>::reverse_iterator rit = l.rbegin();
	//while (rit != l.rend())
	//{
	//	std::cout << *rit << " ";
	//	++rit;
	//}//6 5 4 3 2 1
	//std::cout << std::endl;

	test();

	return 0;
}

6.4rbegin、rend的解释

在这里插入图片描述
在库中，使用的是第一种方式设计的rbegin和rend，为什么呢？没啥意义，感觉单纯与begin，end对称一些。在解引用的时候，一直是解引用的下一个值而已。
在这里插入图片描述


好的，如果本篇文章对你有帮助，不妨点个赞~谢谢。
在这里插入图片描述

EOF

睡觉待开机
关注
专栏目录
初识C++之模拟实现stack、queue和反向迭代器
Masquerena114514的博客
03-12 560
讲解了stl库中的stack和queue的模拟实现、适配器模式、双端队列及反向迭代器的实现和仿函数的概念
C++ 容器 迭代器和算法
Chroniccandy的博客
12-05 767
容器 我们发觉编写的每个程序都或多或少的要存储一些数据,此前C++在这方面只提供了几种最基本的方法: 创建局部或全局变量来保存单个数据的值,以及使用数组来保存多个数据的值. 此篇文章引出的概念：能容纳两个或更多值的数据结构,我们通常称之为容器(container) 在C++标准库中有许多现成的容器,这个容器都经过不断的精心设计和测试封装,可以直接拿来使用,不过需要注意的是,找到最合适的容器只是编程工作的一部分,要实现程序的最优效率,还需一些适当的函数(算法)来处理这个容器内的数据. 数组作为容器的弊端：
[cpp---＞双端队列]
kk1125778230的博客
06-08 168
list优点:任意位置插入删除效率高,不需要扩容;缺点:不支持随机访问,.vector优点:支持随机访问,尾插尾删效率高;缺点:头插和中间插入删除效率低.扩容代价高.dequeue优点:支持随机访问但是没有vector效率高,尾插尾删效率高,扩容只需要拷贝指针即可,代价很低;缺点:中间插入删除效率低或者是不支持随机访问.
【CPP】双端队列简介(deque)
最新发布
2302_79031646的博客
06-01 309
双端队列简介(deque)
4.数据结构C++学习笔记——队列（顺序）
qq_46417568的博客
05-08 737
队列也是一种线性表的特例，其插入和删除操作在表的两边进行，允许插入元素的一端称为队尾，即端，允许删除元素的一端叫队头，即端，它是一种先进先出（FIFO）的线性表，插入元素称为入队，删除元素称为出队。队列的储存结构分为链队和顺序队，常用为循环线性队。图1.1 队列结构示意图逻辑结果：同线性表相同，仍为一对一关系。由于队列具有先进先出的特性，使得队列成为程序设计中的有用工具。脱机打印输出:按申请的先后顺序依次输出多用户系统中，多个用户排成队，分时地循环使用CPU和主存。
带你深入了解队列(c/cpp双版本模拟实现)
weixin_55582891的博客
10-27 130
考虑到学校有好多老师上课，虽然说得是用c语言实现，却用cpp进行操作，现在给大家更新cpp版本的队列的模拟实现，cpp版本的扩容使用的new，函数参数使用的&，可能有同学对指针使用不太熟悉，所以我们同意用&（引用）来实现，方便大家的理解，就不再详细的进行说明了，思路跟c语言实现的一样，只是c和cpp的语言差距有所不同。3.如果队列有多个数据，新建一个节点cur等于队列“头”的下一个地址，然后释放掉队头，再把队头指向cur（以前对头的下一个地址），使得第二个数据成为队头。队列也可以数组和链表的结构实现，
C++数据结构之队列
一个程序猿~
07-09 1922
队列（Queue）与栈一样，是一种线性存储结构。本文会介绍队列。
c++ list, vector, map, set 区别与用法比较
u010112268的博客
07-23 208
List封装了链表,Vector封装了数组, list和vector得最主要的区别在于vector使用连续内存存储的，他支持[]运算符，而list是以链表形式实现的，不支持[]。 Vector对于随机访问的速度很快，但是对于插入尤其是在头部插入元素速度很慢，在尾部插入速度很快。List对于随机访问速度慢得多，因为可能要遍历整个链表才能做到，但是对于插入就快的多了，不需要拷贝和移动数据，只需要改变...
STL tutorial and reference Code
02-09
- `ex06-12.cpp`可能涉及到迭代器的复杂用法，如反向迭代或双端迭代。 - `ex05-08a.cpp`和`ex05-22.cpp`可能分别讨论了算法的使用，如查找、拷贝或替换操作。 - `ex12-01.cpp`可能展示了如何使用`queue`或`stack`，...
STL简介（入门级）
01-07
- **rend()**：返回指向容器第一个元素之前位置的反向迭代器。 - **erase()**：删除容器中的一个元素或一组元素。 - **clear()**：删除容器中的所有元素。 - **size()**：返回容器中元素的数量。 - **swap()**：交换...
顺序队列.cpp 使用顺序表实现的队列c++代码
12-02
使用顺序表实现的队列 包含实现与测试 对应于数据机构与算法分析（c++版）第三版或第二版 Clifford A.Shaffer 重庆大学使用教材
queue.cpp队列的定义
04-07
这是c prime plus 第17章中的学习内容 此部分配和我写的队列的分析一起作为学习使用 biubiu
C++队列实例.cpp
12-17
利用链表构造一个队列类Stack 定义在链表上的最小操作为 插入(insert)—在链表前面增加一个项 获取(del)—获取链表最后一个项，并将之删除(先进先出) 清除(clear)—在链表中删除所有的项
10.【CPP】栈和队列（栈队列互相实现&栈排序||priority_queue||仿函数）
m0_73865858的博客
02-14 448
仿函数（Functor）又称为函数对象（Function Object）是一个能行使函数功能的类。仿函数的语法几乎和我们普通的函数调用一样，不过作为仿函数的类，都必须重载operator()运算符。因为调用仿函数，实际上就是通过类对象调用重载后的operator()运算符。编写程序，对栈进行排序使最小元素位于栈顶。最多只能使用一个其他的临时栈存放数据，但不得将元素复制到别的数据结构（如数组）中。1.默认用vector，默认是大堆（大的优先级高）仿函数less。输出hello and world。
队列原理与用法整理（cpp）
luodaxia_ttt的博客
05-25 644
参考LeetCode的教程。 思想 两个线性数据结构，队列：FIFO，栈：LIFO。 基本实现 #include <iostream> class MyQueue { private: // store elements vector<int> data; // a pointer to indicate the start position int p_start;
Cpp的队列（Queue）学习笔记
PengCoX
08-05 1948
Cpp的队列（Queue）学习笔记 队列是一种先入先出（First In First Out）的数据结构，它的实现用两个整型变量（Head、tail）和一个存储数据的数组（Date[Num]）来实现的。 自定义的数据结构体： struct queue{ int date[Num]; int head; int tail; }; 这里要注意的是结构体内定义的是类型和变量空间，所
CPP使用单链表实现队列
Bananas_3的博客
01-09 164
通过CPP,定义单链表节点,并使用它定义队列的头尾指针,最后实现一个队列
C++队列
a1291714103的博客
07-30 5968
数据结构之队列，C++实现，使用了模板，数组队列和链式队列都有实现
栈与队列解决小型迷宫问题
"小型迷宫数据结构问题，涉及栈与队列的概念及应用，迷宫解题策略通过栈实现回溯。" 在计算机科学中，数据结构是组织、管理和存储数据的方式，它对于高效地执行算法至关重要。在这个问题中，我们关注的是两种基本的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值