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

最新推荐文章于 2023-09-22 16:07:41 发布
最新推荐文章于 2023-09-22 16:07:41 发布
阅读量674 收藏 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

瘦身小蚂蚁
关注
专栏目录
deque容器，stack容器，队列容器queue
weixin_43680743的博客
03-31 298
1、deque容器 双端动态数组 deque容器和vector容器最大的差异： a、deque插入和删除 常数项时间（不会因为数据量的大小 改变操作所耗时） b、deque容器没有容量的概念 以分段连续空间组成。 c、Deque是由一段一段的定量的连续空间构成。 deque容器的API 1、deque容器的构造 和赋值 /* 3.3.3.1 deque构造函数 deque deqT;//默认构造...
C++ queue 和 deque的区别
热门推荐
bemachine的专栏
08-12 2万+
先说queue，queue支持5中基本的操作： empty,
c++基础 STL 第三篇：（deque容器和stack容器）
呋喃吖的博客
07-10 630
文章目录一 deque 的基本概念二 deque 的构造函数三 deque 的赋值操作四 deque 的大小操作五 deque 的插入和删除六 deque 的数据获取七 stack 的基本概念八 stack 的常用接口 一 deque 的基本概念 deque 就是一个双端数组，可以头端和尾端进行插入删除操作。 deque 和 vector 的区别： vector对于头部的插入删除效率低，数据量越大，效率越低 deque相对而言，对头部的插入删除速度回比vector快 vector访问元素时的速度会比de
C++之stack & queue & deque
南方有乔木的博客
06-20 879
C++之stack & queue & deque 目录 1 stack 2 queue 3 deque 1 stack C++ stack(堆栈）是一个容器的改编，它实现了一个先进后出的数据结构（FILO） 使用该容器时需要包含头文件#include<stack> 定义stack对象：...
C++STL之stack和queue以及deque详解
小赵小赵福星高照的博客
11-30 2184
stack和queue以及deque 文章目录stack和queue以及dequestack的使用queue的使用栈的OJ题练习最小栈栈的压入、弹出序列逆波兰表达式求值什么是适配器？栈和队列的模拟实现栈的模拟实现队列的模拟实现dequedeque的使用deque的底层实现deque的优缺点 stack文档 翻译： stack是一种容器适配器，专门用在具有后进先出操作的上下文环境中，其删除只能从容器的一端进行 元素的插入与提取操作。 stack是作为容器适配器被实现的，容器适配器即是对特定类封装作为其底层
C++ STL容器stack和queue详解
09-01
C++ STL（Standard Template Library，标准模板库）提供了两种特殊的线性容器：stack（栈）和queue（队列），它们都是基于顺序容器（如vector或deque）实现的抽象数据类型，用于实现特定的数据操作逻辑。 **1. ...
STL- 常用容器
m0_53263647的博客
02-14 961
一、string容器1、string基本概念本质：string是C++风格的字符串，而string本质上是一个类string和char * 区别：char * 是一个指针string是一个类，类内部封装了char*，管理这个字符串，是一个char*型的容器。特点：string 类内部封装了很多成员方法例如：查找find，拷贝copy，删除delete 替换replace，插入insertstring管理char*所分配的内存，不用担心复制越界和取值越界等，由类内部进行负责。
C++——STL(deque容器、stack容器、queue容器)
没实力的码农写的渣渣博客
06-17 225
deque功能：双端数组可以对头端进行插入和删除； deque和vector区别： vector对于头部的插入和删除效率太低，数据量越大效率越低； deque相对于vector。对于头部的插入删除速度会比vector快； vector访问元素时的速度会比deque快； deque内部工作原理: deque内部有个中控器，维护每段缓冲区中的内容，缓冲区中存放真实数据。 中控器维护的是每个缓冲区的地址，使得使用deque时像一片连续的内存空间。 deque容器的迭代器也是支持随机访问的； deque构造函数：
【C++】STL之适配器---用deque实现栈和队列
最新发布
m0_63198468的博客
09-22 2545
本介绍了什么是适配器，deque，并且使用queue去实现了stack和queue，重点介绍了他们函数接口的使用，以及后面的stack和queue模拟实现。
C++复习笔记--STL的deque容器、stack容器和queue容器
牵一只蜗牛去散步
03-10 510
/ 重新指定容器的长度为 num，若容器变长，则以 elem 值填充新位置，如果容器变短，则末尾超出容器长度的元素将被删除；// 重新指定容器的长度为 num，若容器变长，则以默认值填充新位置。// 在pos位置插入[beg, end)区间的数据，无返回值；// 在pos位置插入一个elem元素的拷贝，返回新数据的位置。// 删除[beg, end)区间的数据，返回下一个数据的位置；// 将 [beg, end) 区间中的数据拷贝赋值给容器。// 构造函数将[beg, end]区间中的元素拷贝到容器。
C++STL入门之Deque,Stack,Queue
41167361的博客
08-12 278
1.Deque容器 1.1Deque介绍 1)deque是“double-ended queue”的缩写，和vector一样都是STL的容器，deque是双端数组，而vector是单端的。 2)deque在接口上和vector非常相似，在许多操作的地方可以直接替换。 3)deque可以随机存取元素（支持索引值直接存取， 用[]操作符或at()方法，这个等下会详讲）。 4)deque头部和尾部添加或移除元素都非常快速。但是在中部安插元素或移除元素比较费时。 5)头文件是deque 1.2deque对象的创建
C++ STL vector & deque & queue & list & stack
good_jiojio的博客
04-15 771
STL：顺序容器
stack, deque 和 queue的对比
weixin_34273481的博客
06-04 245
  stack, deque 和 queue这三个c++的STL的数据结构很类似但又各有不同。 stack是堆栈，没有迭代器，特点是后进先出。用push()将元素压入栈中，top()返回栈顶元素，pop()移除栈顶元素。 deque是双端队列，支持迭代器，使用push_back()在队尾添加元素，pop_back()移除队尾元素，这些跟vector差不多。不同的地方在于deque还可在队首添...
C++复习（三）：STL库之deque、stack、queue、priority_queue容器
cly141220010的博客
02-07 574
本文主要参考https://blog.csdn.net/weixin_34128839/article/details/91686932 queue，stack是基于deque实现的，都是顺序容器，支持随机访问。priority_queue是基于vector实现的，底层数据结构是堆。 list的本质是一个双向链表，内存空间不连续，通过指针进行操作。 deque是一个double-ended......
C++ deque容器详解
qq_52324409的博客
10-29 1767
C++ deque容器详解deque容器基本概念1.deque的构造函数2.deque的赋值操作3.deque的大小操作4.deque的插入和删除5.deque的数据存取 deque容器基本概念 功能：它是一个双端数组，也就是数据结构中的队列，可以对头端和尾端进行插入和删除操作 deque和vector的区别： deque对于头部的插入和删除效率比vector高 vector访问元素时速度比deque快，这和两者的内部实现有关 deque内部工作原理： deque内部有个中控器，维护每段缓冲区中
深入解析C++ STL中的常用容器
09-05
本篇文章将深入解析C++ STL中的一些常用容器，包括顺序性容器、关联容器以及容器适配器。 1. 顺序性容器 - (1) vector `vector` 是一种动态数组，内存中存储是连续的，支持快速随机访问。但由于插入和删除操作...
STL分析（五 deque、queue、stack）
janke114的博客
01-15 202
STL学习记录
C++ STL之 queue和deque用法详解
zdlzf的博客
05-25 8207
C++ queue和deque用法详解 deque可以队首和队尾插入，也可以队首和队尾弹出，支持随机访问，即可以直接用下标来访问元素。它和vector有点像，因为它可以index索引和at()函数索引，当然，也可以迭代器索引。此外，它可以进行指定尺寸的构造-queue就不可以指定尺寸构造。
双端队列（qeque容器类）：#include
vincentlau1231的专栏
12-09 789
<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 <
STL之deque容器
Worthwhile_DUT的博客
10-19 332
deque 是 double-ended queue 的缩写，又称双端队列容器。 deque 容器和 vecotr 容器有很多相似之处，比如： deque 容器也擅长在序列尾部添加或删除元素，而不擅长在序列中间添加或删除元素。 deque 容器也可以根据需要修改自身的容量和大小。 和 vector 不同的是，deque 还擅长在序列头部添加或删除元素。并且更重要的一点是，deque 容器中存储元素并不能保证所有元素都存储到连续的内存空间中。 当需要向序列两端频繁的添加或删除元素时，应首选 deq.
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值