C++ 学习（18）STL - deque容器、stack容器、queue容器

最新推荐文章于 2024-07-22 09:26:11 发布
最新推荐文章于 2024-07-22 09:26:11 发布
阅读量641 收藏 3
点赞数
分类专栏： C++ 文章标签： c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ling1998/article/details/126112636
版权

1、deque容器

deque容器为双端数组，可以对头端和尾端进行插入删除操作。

deque与vector区别：

从两者内部实现比较：

  1. vector对于头部的插入删除效率低，数据量越大，效率越低；deque相对而言，对头部插入删除速度会比vector快
  2. vector访问元素时的速度比deque快

简单理解：vector读数据快，deque写数据快。

deque内部工作原理：

deque内部有个中控器，维护每段缓冲区，缓冲区中存放真实数据；中控器维护的是每个缓冲区的地址，使得使用deque时像一年连续的内存空间。如下图所示：

1.1、deque构造函数

函数原型：

  • deque<T> deqT;        //默认构造形式
  • deque(beg, end);      //构造函数将[beg, end)区间中的元素拷贝给当前deque
  • deque(n, elem);        //构造函数将n个elem拷贝给当前deque
  • deque(const deque& deq); //拷贝构造函数
#include <iostream>
#include <deque>
using namespace std;

void print(const deque<int>& d)
{
	for (deque<int>::const_iterator  it = d.begin(); it < d.end(); it++)
	{
		cout << *it << " ";
	}
	cout << endl;
}

int main()
{
	// STL - deque - 构造函数
	/*函数原型：
		1、deque<T> deqT;       	//默认构造形式
		2、deque(beg, end);     	//构造函数将[beg, end)区间中的元素拷贝给当前deque
		3、deque(n, elem);       	//构造函数将n个elem拷贝给当前deque
		4、deque(const deque& deq); //拷贝构造函数
	*/
	
	//1、deque<T> deqT;
	deque<int> d1;
	for (int i = 0; i < 5; i++)
	{
		d1.push_back(i + 1);
	}
	print(d1);

	//2、deque(beg, end);
	deque<int> d2(d1.begin(), d1.end());
	print(d2);

	//3、deque(n, elem);
	deque<int> d3(5, 8);
	print(d3);

	//4、deque(const deque& deq); 
	deque<int> d4(d1);
	print(d4);

	system("pause");

	return 0;
}

输出结果

1 2 3 4 5
1 2 3 4 5
8 8 8 8 8
1 2 3 4 5 

1.2、deque赋值操作

函数原型：

  • deque& operator=(const deque& deq);  //重载运算符=
  • assign(beg, end);   //将[beg, end)区间中的数据拷贝给当前deque
  • assign(n, elem);     //将n个elem拷贝赋值给本身
#include <iostream>
#include <deque>
using namespace std;

void print(const deque<int>& d)
{
	for (deque<int>::const_iterator it = d.begin(); it < d.end(); it++)
	{
		cout << *it << " ";
	}
	cout << endl;
}

int main()
{
	// STL - deque - 赋值操作
	/*函数原型：
		1、deque& operator=(const deque& deq);  //重载运算符=
		2、assign(beg, end);   //将[beg, end)区间中的数据拷贝给当前deque
		3、assign(n, elem);     //将n个elem拷贝赋值给本身
	*/

	deque<int> d;
	for (int i = 0; i < 5; i++)
	{
		d.push_front(i + 1);
	}
	print(d);

	//1、deque& operator=(const deque& deq);
	deque<int> d1;
	d1 = d;
	print(d1);

	//2、assign(beg, end); 
	deque<int>::iterator it = d1.begin();
	it++;
	deque<int> d2;
	d2.assign(it, d1.end());
	print(d2);

	//3、assign(n, elem);
	deque<int> d3;
	d3.assign(5, 8);
	print(d3);

	system("pause");

	return 0;
}

输出结果

5 4 3 2 1

5 4 3 2 1
4 3 2 1
8 8 8 8 8

1.3、deque大小操作

函数原型：

  • deque.empty();          //判断容器是否为空
  • deque.size();             //返回容器中元素个数
  • deque.resize(num);  //重新指定容器的长度为num，若容器变长，则以默认值填充新位置；如果容器变短，则末尾超出容器长度的元素被删除
  • deque.resize(num, elem); //重新指定容器的长度为num，若容器变长，则以elem值填充新位置；如果容器变短，则末尾超出容器长度的元素被删除
#include <iostream>
#include <deque>
using namespace std;

void print(const deque<int>& d)
{
	for (deque<int>::const_iterator it = d.begin(); it < d.end(); it++)
	{
		cout << *it << " ";
	}
	cout << endl;
}

int main()
{
	// STL - deque - 大小操作
	/*函数原型：
		1、deque.empty();         	//判断容器是否为空
		2、deque.size();            //返回容器中元素个数
		3、deque.resize(num); 		//重新指定容器的长度为num，若容器变长，则以默认值填充新位置；如果容器变短，则末尾超出容器长度的元素被删除
		4、deque.resize(num, elem); //重新指定容器的长度为num，若容器变长，则以elem值填充新位置；如果容器变短，则末尾超出容器长度的元素被删除
	*/

	deque<int> d;
	//1、deque.empty();  
	cout << "1、容器是否为空：" << (d.empty() ? "是" : "否") << endl;

	for (int i = 0; i < 5; i++)
	{
		d.push_front(i + 1);
	}
	cout << "1、容器初始化元素：";
	print(d);
	cout << "1、容器是否为空：" << (d.empty() ? "是" : "否") << endl;

	//2、deque.size();
	cout << "2、容器中元素个数：" << d.size() << endl;

	//3、deque.resize(num);
	d.resize(8);
	cout << "3、容器长度变长后大小：" << d.size() << "，元素：";
	print(d);

	d.resize(3);
	cout << "3、容器长度变短后大小：" << d.size() << "，元素：";
	print(d);

	//4、deque.resize(num, elem);
	d.resize(9, 10);
	cout << "4、容器长度变长后大小：" << d.size() << "，元素：";
	print(d);

	d.resize(5, 6);
	cout << "4、容器长度变短后大小：" << d.size() << "，元素：";
	print(d);

	system("pause");

	return 0;
}

输出结果

1、容器是否为空：是
1、容器初始化元素：5 4 3 2 1
1、容器是否为空：否
2、容器中元素个数：5
3、容器长度变长后大小：8，元素：5 4 3 2 1 0 0 0
3、容器长度变短后大小：3，元素：5 4 3
4、容器长度变长后大小：9，元素：5 4 3 10 10 10 10 10 10
4、容器长度变短后大小：5，元素：5 4 3 10 10

1.4、deque插入和删除

函数原型：

两端操作：

  • push_back(elem);    //在容器尾部添加一个数据
  • push_front(elem);    //在容器头部插入一个数据
  • pop_back();             //删除容器最后一个数据
  • pop_front();             //删除容器第一个数据

指定位置操作：

  • insert(pos, elem);        //在pos位置插入一个elem元素的拷贝，返回新数据的位置
  • insert(pos, n, elem);    //在pos位置插入n个elem数据，无返回值
  • insert(pos, beg, end); //在pos位置插入[beg, end)区间的数据，无返回值
  • erase(pos);                //删除pos位置的数据，返回下一个数据的位置
  • erase(beg, end);        //删除[beg, end)区间的数据，返回下一个数据的位置
  • clear();                        //清空容器中所有数据
#include <iostream>
#include <deque>
using namespace std;

void print(const deque<int>& d)
{
	for (deque<int>::const_iterator it = d.begin(); it < d.end(); it++)
	{
		cout << *it << " ";
	}
	cout << endl;
}

int main()
{
	// STL - deque - 插入和删除
	/*函数原型：
	两端操作：
		1、push_back(elem);     //在容器尾部添加一个数据
		2、push_front(elem);    //在容器头部插入一个数据
		3、pop_back();          //删除容器最后一个数据
		4、pop_front();         //删除容器第一个数据

	指定位置操作：
		5、insert(pos, elem);     //在pos位置插入一个elem元素的拷贝，返回新数据的位置
		6、insert(pos, n, elem);  //在pos位置插入n个elem数据，无返回值
		7、insert(pos, beg, end); //在pos位置插入[beg, end)区间的数据，无返回值
		8、erase(pos);            //删除pos位置的数据，返回下一个数据的位置
		9、erase(beg, end);       //删除[beg, end)区间的数据，返回下一个数据的位置
		10、clear();              //清空容器中所有数据
	*/

	deque<int> d;
	//1、push_back(elem);
	for (int i = 0; i < 3; i++)
	{
		d.push_back(i + 1);
	}

	cout << "1、尾部添加3个数据，当前元素：";
	print(d);

	//2、push_front(elem); 
	for (int i = 10; i < 15; i++)
	{
		d.push_front(i + 1);
	}

	cout << "2、头部插入5个数据，当前元素：";
	print(d);

	//3、pop_back(); 
	d.pop_back();
	cout << "3、尾部删除1个数据，当前元素：";
	print(d);

	//4、pop_front(); 
	d.pop_front();
	cout << "4、头部删除1个数据，当前元素：";
	print(d);

	//5、insert(pos, elem);  
	deque<int>::iterator pos = d.insert(d.begin(), 99);
	cout << "5、在第1位置添加数据，当前元素：";
	print(d);

	//6、insert(pos, n, elem);
	d.insert(pos, 3, 88);
	cout << "6、在第1位置添加数据，当前元素：";
	print(d);

	//7、insert(pos, beg, end)
	deque<int> d2;
	d2.push_back(1);
	d2.push_back(2);

	pos = d.insert(d.begin(), d2.begin(), d2.end());
	cout << "7、在第1位置添加数据，当前元素：";
	print(d);

	//8、erase(pos); 
	d.erase(pos);
	cout << "8、删除第1位置数据，当前元素：";
	print(d);

	//9、erase(beg, end); 
	pos = d.begin();
	pos++;
	d.erase(pos, d.end());
	cout << "9、删除第2位置至尾区间数据，当前元素：";
	print(d);

	//10、clear();  
	d.clear();
	cout << "10、清空数据，容器大小：" << d.size() << "，当前元素：";
	print(d);

	system("pause");

	return 0;
}

输出结果

1、尾部添加3个数据，当前元素：1 2 3
2、头部插入5个数据，当前元素：15 14 13 12 11 1 2 3
3、尾部删除1个数据，当前元素：15 14 13 12 11 1 2
4、头部删除1个数据，当前元素：14 13 12 11 1 2
5、在第1位置添加数据，当前元素：99 14 13 12 11 1 2
6、在第1位置添加数据，当前元素：88 88 88 99 14 13 12 11 1 2
7、在第1位置添加数据，当前元素：1 2 88 88 88 99 14 13 12 11 1 2
8、删除第1位置数据，当前元素：2 88 88 88 99 14 13 12 11 1 2
9、删除第2位置至尾区间数据，当前元素：2
10、清空数据，容器大小：0，当前元素：

1.5、deque数据读取

函数原型：

  • at(int idx);   //返回索引idx所指的数据
  • operator[];  //返回索引idx所指的数据
  • front();       //返回容器中第一个数据元素
  • back();      //返回容器中最后一个数据元素
#include <iostream>
#include <deque>
using namespace std;

void print(const deque<int>& d)
{
	for (deque<int>::const_iterator it = d.begin(); it < d.end(); it++)
	{
		cout << *it << " ";
	}
	cout << endl;
}

int main()
{
	// STL - deque - 数据读取
	/*函数原型：
		1、at(int idx);   //返回索引idx所指的数据
		2、operator[];    //返回索引idx所指的数据
		3、front();       //返回容器中第一个数据元素
		4、back();        //返回容器中最后一个数据元素
	*/

	deque<int> d;
	for (int i = 0; i < 5; i++)
	{
		d.push_back(i + 1);
	}
	cout << "容器中的元素：";
	print(d);

	//1、at(int idx);
	cout << "1、读取第3个元素：" << d.at(2) << endl;

	//2、operator[];
	cout << "2、读取第2个元素：" << d[1] << endl;

	//3、front(); 
	cout << "3、读取第一个元素：" << d.front() << endl;

	//4、back();  
	cout << "4、读取最后一个元素：" << d.back() << endl;

	system("pause");

	return 0;
}

输出结果

容器中的元素：1 2 3 4 5
1、读取第3个元素：3
2、读取第2个元素：2
3、读取第一个元素：1
4、读取最后一个元素：5

1.6、deque排序

算法：

  • sort(iterator beg, iterator end);  //对beg和end区间内元素进行排序

默认升序排序，对于支持随机访问的迭代器的容器（如vector, deque），都可以使用sort进行排序。

#include <iostream>
#include <deque>
#include <algorithm>
using namespace std;

void print(const deque<int>& d)
{
	for (deque<int>::const_iterator it = d.begin(); it < d.end(); it++)
	{
		cout << *it << " ";
	}
	cout << endl;
}

int main()
{
	// STL - deque - 排序
	/*算法：
		sort(iterator beg, iterator end);  //对beg和end区间内元素进行排序
	*/

	deque<int> d;
	d.push_back(33);
	d.push_back(26);
	d.push_back(75);
	d.push_back(18);
	d.push_back(89);

	cout << "容器中的元素：";
	print(d);

	//排序 - 默认升序排序
	sort(d.begin(), d.end());
	cout << "排序后，容器中的元素：";
	print(d);

	system("pause");

	return 0;
}

输出结果

容器中的元素：33 26 75 18 89
排序后，容器中的元素：18 26 33 75 89

2、stack容器

stack是一种先进后出（First In Last Out, FILO）的数据结构，它只有一个出囗，且入囗与出囗共用一个。栈中只有顶端的元素才可以被外界使用，因此栈不允许有遍历行为。栈可以为空，也可以返回栈中的元素个数。栈中进入数据称为入栈（push），弹出数据称为出栈（pop），如下图所示：

2.1、stack常用接囗

函数原型：

构造函数

  • stack<T> stk;                    //stack采用模板类实现，stack对象的默认构造形式
  • stack(const stack& stk);   //拷贝构造函数

赋值操作

  • stack& operator=(const stack& stk);  //重载运算符=

数据存取

  • push(elem); //向栈顶添加元素
  • pop();          //从栈顶移除第一个元素
  • top();           //返回栈顶元素

大小操作

  • empty();  //判断堆栈是否为空
  • size();     //返回栈大小
#include <iostream>
#include <stack>
using namespace std;

int main()
{
	// STL - stack - 常用接囗
	/*函数原型：
		构造函数
		1、stack<T> stk;              //stack采用模板类实现，stack对象的默认构造形式
		2、stack(const stack& stk);   //拷贝构造函数

		赋值操作
		3、stack& operator=(const stack& stk);  //重载运算符=

		数据存取
		4、push(elem); //向栈顶添加元素
		5、pop();      //从栈顶移除第一个元素
		6、top();      //返回栈顶元素

		大小操作
		7、empty();  //判断堆栈是否为空
		8、size();   //返回栈大小
	*/

	//1、stack<T> stk; 
	stack<int> s1;

	//7、empty();  //判断堆栈是否为空
	cout << "7、栈是否为空：" << (s1.empty() ? "是" : "否") << endl;

	//4、push(elem); //向栈顶添加元素
	s1.push(20);
	s1.push(17);

	//8、size();   //返回栈大小
	cout << "8、栈大小：" << s1.size() << endl;

	//6、top();      //返回栈顶元素
	cout << "6、栈顶元素：" << s1.top() << endl;

	//5、pop();      //从栈顶移除第一个元素
	s1.pop();
	cout << "5、移除栈顶元素后，栈大小：" << s1.size() << endl;

	//2、stack(const stack& stk);   //拷贝构造函数
	stack<int> s2(s1);
	cout << "2、通过拷贝构造函数初始化栈，栈大小：" << s1.size() << endl;

	//3、stack& operator=(const stack& stk);  //重载运算符=
	stack<int> s3;
	s3 = s2;
	cout << "3、通过重载运算符=赋值栈，栈大小：" << s1.size() << endl;

	system("pause");

	return 0;
}

输出结果

7、栈是否为空：是
8、栈大小：2
6、栈顶元素：17
5、移除栈顶元素后，栈大小：1
2、通过拷贝构造函数初始化栈，栈大小：1
3、通过重载运算符=赋值栈，栈大小：1

3、queue容器

queue是一种先进先出（First In First Out, FIFO）的数据结构，它有两个出囗，只有队头和队尾能被外界访问，因此不允许有遍历 为，可以判断队列是否为空，也可以返回队列大小，如下图所示：

3.1、queqe常用接囗

构造函数

  • queue<T> que;                   //queue采用模板类实现，queue对象的默认构造形式
  • queue(const queue& que); //拷贝构造函数

赋值操作

  • queue& operator(const queue& que);  //重载运算符=

数据存取

  • push(elem);  //向队尾添加元素
  • pop();           //从队头移除第一个元素
  • back();         //返回最后一个元素
  • front();         //返回第一个元素

大小操作

  • empty();  //判断队列是否为空
  • size();      //返回栈大小
#include <iostream>
#include <queue>
using namespace std;

int main()
{
	// STL - queue - 常用接囗
	/*函数原型：
		构造函数
		1、queue<T> que;            //queue采用模板类实现，queue对象的默认构造形式
		2、queue(const queue& que); //拷贝构造函数

		赋值操作
		3、queue& operator(const queue& que);  //重载运算符=

		数据存取
		4、push(elem);  //向队尾添加元素
		5、pop();       //从队头移除第一个元素
		6、back();      //返回最后一个元素
		7、front();     //返回第一个元素

		大小操作
		8、empty();  //判断队列是否为空
		9、size();   //返回栈大小
	*/

	//1、queue<T> que; 默认构造函数
	queue<int> q1;

	//4、push(elem);  //向队尾添加元素
	q1.push(22);
	q1.push(16);
	q1.push(67);

	//9、size();   //返回栈大小
	cout << "9、添加元素后，队列大小：" << q1.size() << endl;

	//6、back();      //返回最后一个元素
	cout << "6、最后一个元素：" << q1.back() << endl;

	//7、front();     //返回第一个元素
	cout << "7、第一个元素：" << q1.front() << endl;

	//2、queue(const queue & que); //拷贝构造函数
	queue<int> q2(q1);
	cout << "2、拷贝构造函数，队列大小：" << q1.size() << endl;

	//3、queue& operator(const queue& que);  //重载运算符=
	queue<int> q3 = q1;
	cout << "3、重载运算符=，队列大小：" << q1.size() << endl;

	cout << "8、重载运算符=，队列是否为空：" << (q1.empty() ? "是" : "否") << endl;

	//8、empty();  //判断队列是否为空
	while (!q1.empty())
	{
		//5、pop();       //从队头移除第一个元素
		q1.pop();
	}
	cout << "5、移除所有元素后，队列大小：" << q1.size() << endl;

	system("pause");

	return 0;
}

输出结果

9、添加元素后，队列大小：3
6、最后一个元素：67
7、第一个元素：22
2、拷贝构造函数，队列大小：3
3、重载运算符=，队列大小：3
8、重载运算符=，队列是否为空：否
5、移除所有元素后，队列大小：0

瘦身小蚂蚁
关注
专栏目录
C++ STL容器stack和queue详解
09-01
C++ STL（Standard Template Library，标准模板库）提供了两种特殊的线性容器：stack（栈）和queue（队列），它们都是基于顺序容器（如vector或deque）实现的抽象数据类型，用于实现特定的数据操作逻辑。 **1. ...
C++常用操作
weixin_44265474的博客
02-02 843
Vector 二维数组 vector.push_back(nums[i]); vector.pop_back();
C++中queue使用详细说明
热门推荐
但行好事，莫问前程
03-30 2万+
一、queue的介绍 queue 翻译为队列，在 STL 中主要则是实现了一个先进先出的容器。 二、queue的定义 单独定义一个 queue： queue<typename> name; //这里的typename可以是任何基本类型，例如 int、double、char、结构体等，也可以是STL标准容器，例如vector、set、queue等。 三、queue容器内元素的访问 由于队列（queue）本身就是一种先进先出的限制性数据结构，因此在 ...
【C++】deque以及优先级队列
最新发布
dab112的博客
07-22 1726
介绍了deque以及优先级队列的使用细则，同时也提及了适配器以及反向迭代器
C++复习（三）：STL库之deque、stack、queue、priority_queue容器
cly141220010的博客
02-07 562
本文主要参考https://blog.csdn.net/weixin_34128839/article/details/91686932 queue，stack是基于deque实现的，都是顺序容器，支持随机访问。priority_queue是基于vector实现的，底层数据结构是堆。 list的本质是一个双向链表，内存空间不连续，通过指针进行操作。 deque是一个double-ended......
C++ STL之 queue和deque用法详解
zdlzf的博客
05-25 8031
C++ queue和deque用法详解 deque可以队首和队尾插入，也可以队首和队尾弹出，支持随机访问，即可以直接用下标来访问元素。它和vector有点像，因为它可以index索引和at()函数索引，当然，也可以迭代器索引。此外，它可以进行指定尺寸的构造-queue就不可以指定尺寸构造。
C++复习笔记--STL的deque容器、stack容器和queue容器
牵一只蜗牛去散步
03-10 488
/ 重新指定容器的长度为 num，若容器变长，则以 elem 值填充新位置，如果容器变短，则末尾超出容器长度的元素将被删除；// 重新指定容器的长度为 num，若容器变长，则以默认值填充新位置。// 在pos位置插入[beg, end)区间的数据，无返回值；// 在pos位置插入一个elem元素的拷贝，返回新数据的位置。// 删除[beg, end)区间的数据，返回下一个数据的位置；// 将 [beg, end) 区间中的数据拷贝赋值给容器。// 构造函数将[beg, end]区间中的元素拷贝到容器。
深入解析C++ STL中的常用容器
09-05
本篇文章将深入解析C++ STL中的一些常用容器，包括顺序性容器、关联容器以及容器适配器。 1. 顺序性容器 - (1) vector `vector` 是一种动态数组，内存中存储是连续的，支持快速随机访问。但由于插入和删除操作...
C++标准模板库(STL) -容器
11-05
STL的代码从广义上讲分为三类：algorithm（算法）、container（容器）和iterator（迭代器），几乎所有的代码都采用了...在C++标准中，STL被组织为下面的13个头文件：、<deque>、、、、、、 、、<queue>、、<stack>和。
STL常用容器详细解析
09-05
本文主要探讨STL中的常用容器，包括顺序性容器（vector、deque、list）、关联容器（map、set）以及容器适配器（queue、stack）。 1. 顺序性容器 - (1) vector vector是一种动态数组，其内存空间是连续的，支持...
cPP.rar_c++ 容器使用_容器
09-19
首先，C++中的容器分为几种主要类型：顺序容器（如vector、deque和list）、关联容器（如set、multiset、map和multimap）以及特殊容器（如stack、queue和priority_queue）。每个容器都有其特定的用途和性能特点。 1....
C++学习笔记——STL常用容器——vector和deque
潘芝的博客
03-01 522
vector和数组很相似，也被称为单端数组，但也有区别，数组是静态空间，而vector可以动态扩展。 动态扩展：不是在原空间之后开辟新空间，而是找一个更大的空间，把数据拷贝到新空间，最后释放原空间。 vector的迭代器支持随机访问。 vector构造函数： 函数原型： //采用模板实现类实现，默认构造函数 vector<T> v; //将v[begin(), end())...
C++ deque容器
ChaoChao66666的博客
09-29 706
1. deque容器基本概念 2. deque构造函数 3. deque赋值操作 4. deque大小操作 5. deque插入和删除 6. deque数据存取 7. deque排序
C++编程——deque容器
professor_tao的博客
05-18 488
文章目录1 deque容器基本概念2 deque容器构造函数3 deque容器赋值操作4 deque容器大小操作5 deque容器的插入与删除6 deque容器数据存取7 deuqe容器排序 1 deque容器基本概念 功能： 双端数组，可以对头端进行插入删除操作 deque与vector的区别： vector对于头部的插入删除效率低，数据量越大，效率越低(因为vector是单端数据，头插需要将后面的数据向后移动后才能插入，头删的话需要将后面的数据向前移动) deque相对而言，对头部的插入删除速度会
STL容器 vector,list,deque 性能比较
木牛的博客
07-12 476
测试项目静态数组动态数组vectorlistdeque初始化★★★★★★★★★★★★★★☆★★★☆☆★★★★☆前向遍历★★★★★★★★★★★★★★☆★★★★☆★★★★☆后向遍历★★★★★★★★★★★★★★☆★★★★☆★★★★☆随机访问★★★★★★★★★★★★★★☆★☆☆☆☆★★★☆☆后端插入N/AN/A★★★★★★★★★☆★★★★★后端移除N/AN/A★★★★★★★★★☆★★★★★前端插入N/AN/A★★☆☆☆。
stack, deque 和 queue的对比
weixin_34273481的博客
06-04 234
  stack, deque 和 queue这三个c++的STL的数据结构很类似但又各有不同。 stack是堆栈，没有迭代器，特点是后进先出。用push()将元素压入栈中，top()返回栈顶元素，pop()移除栈顶元素。 deque是双端队列，支持迭代器，使用push_back()在队尾添加元素，pop_back()移除队尾元素，这些跟vector差不多。不同的地方在于deque还可在队首添...
C++知识点24——使用C++标准库（顺序容器deque的初始化，赋值，访问，添加，删除，交换与迭代器失效）
Master Cui的博客
08-13 1178
deque容器是双端队列，使用前，需要添加#include <deque> deque的内存结构如下： 根据上图可知，deque和vector，string稍有不同，deque的内存是分段连续内存结构，所以，deque的内存在增长的时候，也是分段增长的，不会像vector那样复制所有元素，然后重新分配内存，所以不存在预分配空间，所以就没有capacity函数，但是仍然存在预分配内存的情况，所以仍然有shrink_to_fit函数来使内存空间大小和元素个数相匹配。 正是由于分段增长.
【c++】【STL】stack类、queue类、deque类详解及模拟
2301_79551553的博客
03-26 1026
4.1 deque的原理介绍deque(双端队列：是一种双开口的连续空间的数据结构，双开口的含义是：可以在头尾两端进行插入和删除操作，且时间复杂度为O(1)，与vector比较，头插效率高，不需要搬移元素；与list比较，空间利用率比较高。这节课我们学了容器适配器vector、list类的模拟、deque的底层设计，看到了他迭代器的复杂应用。
双端队列（qeque容器类）：#include
vincentlau1231的专栏
12-09 778
<br />　deque（读音：deck，意即：double queue）容器类与vector类似，支持随机访问和快速插入删除，它在容器中某一位置上的操作所花费的是线性时间。与vector不同的是，deque还支持从开始端插入数据：<br />push_front()。此外deque也不支持与vector的capacity()、reserve()类似的操作。<br /> <br /> <br />//stl_cpp_9.cpp<br />#include <iostream><br />#include <
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值