C++学习 --deque

已于 2023-12-26 23:23:11 修改
阅读量98 收藏 1
点赞数
分类专栏： C++ 文章标签： c++ 学习 开发语言
于 2023-11-20 23:14:53 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_25500415/article/details/134519503
版权

目录

1， 什么是deque

2， 创建deque

3， 替换(assign)

4， 插入元素(insert)

5， 头插( push_front)

6， 尾插( push_back)

7， 查询(at)

8， 头元素(front)

9， 尾元素(back)

10， 头删(pop_front)

11， 尾删(pop_back)

12， 获取长度(size)

13， 设置长度(resize)

14， 判断是否为空(empty)

15， 指定元素删除(erase)

16， 清空(clear)

17， 交换元素(swap)

1， 什么是deque

C++中一种容器数据类型， 也叫双端数组， 可以在deque的头尾进行插入删除操作

deque通过中控器控制缓冲区， 缓冲区存放的是真实的数据

 需要在导入头文件#include <deque>， 才能使用deque

2， 创建deque

通过deque<数据类型> 对象名， 可创建deque， 数据类型可以是标准数据类型， 也可以是自定义类型

#include <iostream>
#include <string>
#include <deque>

using namespace std;

class Myclass
{
public:
	Myclass(string name, int age) :m_name(name), m_age(age) {};
	string m_name;
	int m_age;
};

int main()
{
	Myclass m1("aaa", 1);
	Myclass m2("bbb", 2);
	Myclass m3("ccc", 3);

	//内置数据类型
	deque<string> d1;                      //仅创建
	deque<string> d2 = {"a", "b", "c"};    //创建并赋值
	deque<string> d3(d2);                  //拷贝构造创建
	deque<string> d4(d2.begin(), d2.end());//迭代器区间方式创建赋值
	deque<string> d5(5, "a");              //指定长度创建
	deque<deque<string>> dd1 = { d2, d3, d4, d5 }; //嵌套

	//自定义数据类型
	deque<Myclass> d6;                      //仅创建
	deque<Myclass> d7 = {m1, m2, m3};       //创建并赋值
	deque<Myclass> d8(d7);                  //拷贝构造创建
	deque<Myclass> d9(d7.begin(), d7.end());//迭代器区间方式创建赋值
	deque<Myclass> d10(5, m1);              //指定长度创建
	deque<deque<Myclass>> dd2 = { d7, d8, d9, d10 };//嵌套

	system("pause");

	return 0;
}

3， 替换(assign)

assign是用新的元素替换原来deque的元素

#include <iostream>
#include <string>
#include <deque>

using namespace std;

class Myclass
{
public:
	Myclass(string name, int age) :m_name(name), m_age(age) {};
	string m_name;
	int m_age;
};

int main()
{
	Myclass m1("aaa", 1);
	Myclass m2("bbb", 2);
	Myclass m3("ccc", 3);

	//内置数据类型
	deque<string> d1 = { "a", "b", "c" };
    //d1数据被替换为5个a
	d1.assign(5, "a");
	
	//自定义数据类型
	deque<Myclass> d2 = { m1, m2, m3 };
    //d2数据被替换为5个m1                      
	d2.assign(5, m1);

	system("pause");

	return 0;
}

4， 插入元素(insert)

insert是向vector指定位置， 插入元素， 支持一次添加多个元素， 插入多个元素时，元素范围通过迭代器指定

#include <iostream>
#include <string>
#include <deque>

using namespace std;

class Myclass
{
public:
	Myclass(string name, int age) :m_name(name), m_age(age) {};
	string m_name;
	int m_age;
};

int main()
{
	Myclass m1("aaa", 1);
	Myclass m2("bbb", 2);
	Myclass m3("ccc", 3);

	//内置数据类型
	deque<string> d1 = { "a", "b", "c" };
	//在d1的索引0处插入a1, d1 = { "a1", "a", "b", "c" }
	d1.insert(d1.begin(), "a1");
	deque<string>::iterator it = d1.begin();
	it++;
	//在d1的索引1处插入a2, d1 = { "a1", "a2", "a", "b", "c" }
	d1.insert(it, "a2");
	deque<string>::iterator it1 = d1.begin();
	it1++;
	it1++;
	//在d1的索引2处插入a3, d1 = { "a1", "a2", "a3", "a", "b", "c" }
	d1.insert(it1, "a3");
	//在d1的索引0处插入多个元素, d2= { "a1", "a2", "a3", "a", "b", "c", "a1", "a2", "a3", "a", "b", "c" }
	d1.insert(d1.begin(), d1.begin(), d1.end());
	
	//自定义数据类型
	deque<Myclass> d2 = { m1, m2, m3 };                      
	//在d2的索引0处插入m2, d2 = { m2, m1, m2, m3 }
	d2.insert(d2.begin(), m2);
	deque<Myclass>::iterator it2 = d2.begin();
	it2++;
	//在d2的索引1处插入m3, d2 = { m2, m3, m1, m2, m3 }
	d2.insert(it2, m3);
	deque<Myclass>::iterator it3 = d2.begin();
	it3++;
	it3++;
	//在d2的索引2处插入m1, d2= { m2, m3, m1, m1, m2, m3 }
	d2.insert(it3, m1);
	//在d2的索引0处插入多个元素, d2= { m2, m3, m1, m1, m2, m3, m2, m3, m1, m1, m2, m3 }
	d2.insert(d2.begin(), d2.begin(), d2.end());

	system("pause");

	return 0;
}

5， 头插( push_front)

push_front是在头部插入元素， 只能单个添加

#include <iostream>
#include <string>
#include <deque>

using namespace std;

class Myclass
{
public:
	Myclass(string name, int age) :m_name(name), m_age(age) {};
	string m_name;
	int m_age;
};

int main()
{
	Myclass m1("aaa", 1);
	Myclass m2("bbb", 2);
	Myclass m3("ccc", 3);

	//内置数据类型
	deque<string> d1 = { "a", "b", "c" };
	//d1 = { "a1", "a", "b", "c" }
	d1.push_front("a1");
	
	//自定义数据类型
	deque<Myclass> d2 = { m1, m2, m3 };  
	//d2 = {m3, m1, m2, m3 }
	d2.push_front(m3);

	system("pause");

	return 0;
}

6， 尾插( push_back)

push_back是在尾部插入元素， 只能单个添加

#include <iostream>
#include <string>
#include <deque>

using namespace std;

class Myclass
{
public:
	Myclass(string name, int age) :m_name(name), m_age(age) {};
	string m_name;
	int m_age;
};

int main()
{
	Myclass m1("aaa", 1);
	Myclass m2("bbb", 2);
	Myclass m3("ccc", 3);

	//内置数据类型
	deque<string> d1 = { "a", "b", "c" };
	//d1 = { "a", "b", "c", "a1" }
	d1.push_back("a1");
	
	//自定义数据类型
	deque<Myclass> d2 = { m1, m2, m3 };  
	//d2 = { m1, m2, m3, m3 }
	d2.push_back(m3);

	system("pause");

	return 0;
}

7， 查询(at)

通过对象名[索引]或者对象名.at(索引)， 获取deque中的元素

#include <iostream>
#include <string>
#include <deque>

using namespace std;

class Myclass
{
public:
	Myclass(string name, int age) :m_name(name), m_age(age) {};
	string m_name;
	int m_age;
};

int main()
{
	Myclass m1("aaa", 1);
	Myclass m2("bbb", 2);
	Myclass m3("ccc", 3);

	//内置数据类型
	deque<string> d1 = { "a", "b", "c" };
	//打印b
	cout << d1.at(1) << endl;
	//打印c
	cout << d1[2] << endl;
	
	//自定义数据类型
	deque<Myclass> d2 = { m1, m2, m3 };  
	//打印bbb 2
	cout << d2.at(1).m_name << " " << d2.at(1).m_age << endl;
	//打印ccc 3
	cout << d2[2].m_name << " " << d2[2].m_age << endl;
	

	system("pause");

	return 0;
}

8， 头元素(front)

通过对象.front()，获取deque的头元素

#include <iostream>
#include <string>
#include <deque>

using namespace std;

class Myclass
{
public:
	Myclass(string name, int age) :m_name(name), m_age(age) {};
	string m_name;
	int m_age;
};

int main()
{
	Myclass m1("aaa", 1);
	Myclass m2("bbb", 2);
	Myclass m3("ccc", 3);

	//内置数据类型
	deque<string> d1 = { "a", "b", "c" };
	//打印a
	cout << d1.front() << endl;
	
	//自定义数据类型
	deque<Myclass> d2 = { m1, m2, m3 };  
	//打印aaa 1
	cout << d2.front().m_name << " " << d2.front().m_age << endl;

	system("pause");

	return 0;
}

9， 尾元素(back)

通过对象.back()，获取deque的尾元素

#include <iostream>
#include <string>
#include <deque>

using namespace std;

class Myclass
{
public:
	Myclass(string name, int age) :m_name(name), m_age(age) {};
	string m_name;
	int m_age;
};

int main()
{
	Myclass m1("aaa", 1);
	Myclass m2("bbb", 2);
	Myclass m3("ccc", 3);

	//内置数据类型
	deque<string> d1 = { "a", "b", "c" };
	//打印c
	cout << d1.back() << endl;
	
	//自定义数据类型
	deque<Myclass> d2 = { m1, m2, m3 };  
	//打印ccc 3
	cout << d2.back().m_name << " " << d2.back().m_age << endl;

	system("pause");

	return 0;
}

10， 头删(pop_front)

通过对象.pop_front()，删除deque的头元素

#include <iostream>
#include <string>
#include <deque>

using namespace std;

class Myclass
{
public:
	Myclass(string name, int age) :m_name(name), m_age(age) {};
	string m_name;
	int m_age;
};

int main()
{
	Myclass m1("aaa", 1);
	Myclass m2("bbb", 2);
	Myclass m3("ccc", 3);

	//内置数据类型
	deque<string> d1 = { "a", "b", "c" };
	//d1 = { "b", "c" }
	d1.pop_front();
	
	//自定义数据类型
	deque<Myclass> d2 = { m1, m2, m3 };  
	//d2 = { m2, m3 }
	d2.pop_front();

	system("pause");

	return 0;
}

11， 尾删(pop_back)

通过对象.pop_back()，删除deque的尾元素

#include <iostream>
#include <string>
#include <deque>

using namespace std;

class Myclass
{
public:
	Myclass(string name, int age) :m_name(name), m_age(age) {};
	string m_name;
	int m_age;
};

int main()
{
	Myclass m1("aaa", 1);
	Myclass m2("bbb", 2);
	Myclass m3("ccc", 3);

	//内置数据类型
	deque<string> d1 = { "a", "b", "c" };
	//d1 = { "a", "b" }
	d1.pop_back();
	
	//自定义数据类型
	deque<Myclass> d2 = { m1, m2, m3 };  
	//d2 = { m1, m2 }
	d2.pop_back();

	system("pause");

	return 0;
}

12， 获取长度(size)

通过对象名.size()， 获取deque的长度

#include <iostream>
#include <string>
#include <deque>

using namespace std;

class Myclass
{
public:
	Myclass(string name, int age) :m_name(name), m_age(age) {};
	string m_name;
	int m_age;
};

int main()
{
	Myclass m1("aaa", 1);
	Myclass m2("bbb", 2);
	Myclass m3("ccc", 3);

	//内置数据类型
	deque<string> d1 = { "a", "b", "c" };
	//打印3
	cout << d1.size() << endl;
	
	//自定义数据类型
	deque<Myclass> d2 = { m1, m2, m3 };  
	//打印3
	cout << d2.size() << endl;

	system("pause");

	return 0;
};

13， 设置长度(resize)

通过对象名.resize()， 设置deque的长度

#include <iostream>
#include <string>
#include <deque>

using namespace std;

class Myclass
{
public:
	Myclass() {};
	Myclass(string name, int age) :m_name(name), m_age(age) {};
	string m_name;
	int m_age;
};

int main()
{
	Myclass m1("aaa", 1);
	Myclass m2("bbb", 2);
	Myclass m3("ccc", 3);

	//内置数据类型
	deque<string> d1 = { "a", "b", "c" };
    //设置长度为10
	d1.resize(10);
	//打印10
	cout << d1.size() << endl;
	
	//自定义数据类型
	deque<Myclass> d2 = { m1, m2, m3 };  
	//自定义数据类型设置长度时，自定义类需要提供默认构造函数
	d2.resize(10);
	//打印10
	cout << d2.size() << endl;

	system("pause");

	return 0;
}

14， 判断是否为空(empty)

通过对象名.empty()， 判断deque是否为空， 为空返回1， 不为空返回0；

#include <iostream>
#include <string>
#include <deque>

using namespace std;

class Myclass
{
public:
	Myclass() {};
	Myclass(string name, int age) :m_name(name), m_age(age) {};
	string m_name;
	int m_age;
};

int main()
{
	Myclass m1("aaa", 1);
	Myclass m2("bbb", 2);
	Myclass m3("ccc", 3);

	//内置数据类型
	deque<string> d1 = { "a", "b", "c" };
	//打印0
	cout << d1.empty() << endl;
	
	//自定义数据类型
	deque<Myclass> d2 = { m1, m2, m3 };  
	//打印0
	cout << d2.empty() << endl;

	system("pause");

	return 0;
}

15， 指定元素删除(erase)

通过对象名.erase(迭代器名称)， 删除迭代器指向的元素， 可指定迭代器区间删除多个元素

#include <iostream>
#include <string>
#include <deque>

using namespace std;

class Myclass
{
public:
	Myclass() {};
	Myclass(string name, int age) :m_name(name), m_age(age) {};
	string m_name;
	int m_age;
};

int main()
{
	Myclass m1("aaa", 1);
	Myclass m2("bbb", 2);
	Myclass m3("ccc", 3);

	//内置数据类型
	deque<string> d1 = { "a", "b", "c" };
	//删除单个元素， d1 = { "b", "c" }
	d1.erase(d1.begin());
	//指定迭代器区间删除元素, d1 = {}
	d1.erase(d1.begin(), d1.end());
	
	//自定义数据类型
	deque<Myclass> d2 = { m1, m2, m3 };  
	//删除单个元素, d2 = { m2, m3 }
	d2.erase(d2.begin());
	//指定迭代器区间删除元素, d2 = {}
	d2.erase(d2.begin(), d2.end());

	system("pause");

	return 0;
}

16， 清空(clear)

通过对象.clear()， 清空对象中的元素

#include <iostream>
#include <string>
#include <deque>

using namespace std;

class Myclass
{
public:
	Myclass() {};
	Myclass(string name, int age) :m_name(name), m_age(age) {};
	string m_name;
	int m_age;
};

int main()
{
	Myclass m1("aaa", 1);
	Myclass m2("bbb", 2);
	Myclass m3("ccc", 3);

	//内置数据类型
	deque<string> d1 = { "a", "b", "c" };
	//清空元素， d1 = { }
	d1.clear();
	
	//自定义数据类型
	deque<Myclass> d2 = { m1, m2, m3 };  
	//清空元素， d2 = { }
	d2.clear();
	
	system("pause");

	return 0;
}

17， 交换元素(swap)

通过对象名1.swap(对象名2)， 可交换两个deque中的元素， 元素类型需要一致

#include <iostream>
#include <string>
#include <deque>

using namespace std;

class Myclass
{
public:
	Myclass() {};
	Myclass(string name, int age) :m_name(name), m_age(age) {};
	string m_name;
	int m_age;
};

int main()
{
	Myclass m1("aaa", 1);
	Myclass m2("bbb", 2);
	Myclass m3("ccc", 3);

	//内置数据类型
	deque<string> d1 = { "a", "b", "c" };
	deque<string> d2 = { "1", "2", "3" };
	//d1 = { "1", "2", "3" }, d2 = { "a", "b", "c" }
	d1.swap(d2);
	
	//自定义数据类型
	deque<Myclass> d3 = { m1, m2, m3 }; 
	deque<Myclass> d4 = { m3, m2, m1 }; 
	
	//d3 = { m3, m2, m1 }, d4 = { m1, m2, m3 } 
	d3.swap(d4);

	system("pause");

	return 0;
}

qq_25500415
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C++ - SGI 版本 STL源码
10-25
通过研究SGI版STL源码，开发者不仅可以深入理解C++ STL的工作原理，还能学习如何设计高效的数据结构和算法。这对于提升C++编程技能，优化代码性能，以及自定义STL容器和算法都大有裨益。在实际项目中，理解和利用STL...
NCRE-C++电子教案.rar
08-11
《NCRE-C++电子教案》是一份专门为全国计算机等级考试（NCRE）第二级C++程序设计准备的教学资源。...这份教案详细覆盖了NCRE-C++考试的关键知识点，通过学习，考生不仅能为考试做好准备，还能建立起坚实的C++编程基础。
C++ 清空队列(queue)的几种方法
热门推荐
木牛的博客
03-12 1万+
C++ 清空队列(queue)的几种方法 C++中的queue自身是不支持clear操作的，但是双端队列deque是支持clear操作的。 方法一 直接用空的队列对象赋值 queue<int> q1; // process // ... q1 = queue<int>(); 方法二 遍历出队列 while (!Q.empty()) Q.pop(); 方法三 使用swap，这种是最高效的，定义clear，保持STL容器的标准。 void clear(queue<int&g
C++ deque容器-48-deque元素存取和排序操作
Anthony_tester的博客
08-01 2394
这篇来学习C++中deque容器的元素存取和排序操作。和前面vector容器一样，也是根据at(index) 和[index]来返回所对应位置的元素，也可以获取容器第一个元素和最后一个元素。当然可以获取，如果使用赋值语句，更改获取到的元素，这个过程就元素的修改也就是存入容器操作。 1.deque获取元素相关api 元素读取相关函数原型 at(int id); //返回索引id所指的数据 operator[id]; //返回索引id所指的数据 front(); // 返回容器.
C++学习3-deque容器
m0_37768370的博客
08-03 50
deque允许头进头出，在这种情况下，deque的效率要比vector更高，但deque的访问速度不如vectror。
C++ -- 学习系列 std::deque 的原理与使用
qq_33775774的博客
09-30 1401
std::deque 是 c++ 一种序列式容器，其与 vector 类似，其底层内存都是连续的，不同的地方在于， vector 是一端开口，在一端放入数据与扩充空间，而 deque 是双端均开口，都可以放入数据与扩充空间。
C++学习-STL简介
m0_37768370的博客
07-30 49
为了避免大量的重复性工作诞生，分为容器、算法和迭代器三类，大量使用模版。六大组件：容器、算法、迭代器、仿函数、适配器、空间配置器。
C++ deque容器-47-deque大小操作和插入和删除
Anthony_tester的博客
07-31 1191
继续学习双端数组deque的api，前面学习了deque的构造和赋值操作，还有始终一样的遍历容器代码操作。这里先学习deque大小操作，主要有判断容器是否为空，元素总数多少，还有修改容器大小操作。然后学习deque的插入和删除相关API 1.deque的大小操作 函数原型 首先empty() 如为空返回1，如果不为空返回0 #include <iostream> #include <string> #include <deque> using name.
【C++】---STL容器适配器之底层deque浅析
weixin_75128035的博客
04-28 949
stack是一种后进先出的特殊线性数据结构，因此只要具有push_back()和pop_back()操作的线性结构，都可 以作为stack的底层容器，比如vector和list都可以；queue是先进先出的特殊线性数据结构，只要具有 push_back和pop_front操作的线性结构，都可以作为queue的底层容器，比如list。因此在实际中，需要线性结构时，大多数情况下优先考虑vector和list，deque的应用并不多，不适合大量的头部和中间插入删除，也不适合大量的随机访问。1、什么是deque？
6-3 Deque_pta_C++_6-3deque_
10-02
标题中的“6-3 Deque”指...总之，这个PTA练习旨在帮助学习者深入理解双端队列的概念，熟悉C++中的`std::deque`容器，并能够熟练地在实际问题中应用它。通过这个练习，不仅可以增强数据结构知识，还能提高C++编程技能。
c++ -- stl 学习笔记
11-02
STL（Standard Template Library，标准模板库）是C++编程语言中的一个重要组成部分，它提供了...通过深入学习SGI STL的源码和隐式类型转换，开发者能够更深入地理解STL的工作原理，从而编写出更加高效和可靠的C++程序。
50个C、C++面试题_C-C++_面试C++_
09-28
在C和C++编程语言的世界里，面试题通常旨在测试应聘者的基础知识、编程技巧、问题解决能力和对语言特性的理解。以下是对"50个C、C++面试题"相关...通过深入学习和实践这些主题，求职者可以为C、C++的面试做好充分准备。
C语言 | Leetcode C语言题解之第337题打家劫舍III
m0_59237910的博客
08-15 357
C语言 | Leetcode C语言题解之第337题打家劫舍III
C++匿名函数lamba简介
yao_tao11的博客
08-18 543
Lambda 表达式是 C++11 引入的一个功能，允许你在代码中定义匿名函数（即没有名字的函数）。这种表达式可以用于简化函数对象的定义，并使得代码更简洁。Lambda 表达式特别适用于局部的、一次性的函数对象，如用于 STL 算法中。捕获方式含义[ ]空捕获列表，Lambda不能使用所在函数中的变量.[names]names是一个逗号分隔的名字列表，这些名字都是Lambda所在函数的局部变量。默认情况下，这些变量会被拷贝，然后按值传递，名字前面如果使用了&，则按引用传递[&]
c++编程（22）——STL（6）set
2301_77239666的博客
08-16 1065
欢迎来到博主的专栏——c++编程博主ID：代码小豪。
【漫谈C语言和嵌入式011】嵌入式系统中常用的校验方式
最新发布
2403_83044722的博客
08-18 499
在嵌入式系统中，选择合适的校验方式取决于应用场景的需求。简单的数据传输可以使用奇偶校验或校验和，而对于更复杂、更可靠的数据传输，CRC和汉明码则是更好的选择。
C++ | Leetcode C++题解之第337题打家劫舍III
Ddddddd_158的博客
08-15 361
C++ | Leetcode C++题解之第337题打家劫舍III
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值