【C++提高编程-05】----C++之Deque容器实战

🎩 欢迎来到技术探索的奇幻世界👨‍💻

📜 个人主页：@一伦明悦-CSDN博客

✍🏻 作者简介： C++软件开发、Python机器学习爱好者

🗣️ 互动与支持：💬评论 👍🏻点赞 📂收藏 👀关注+

如果文章有所帮助，欢迎留下您宝贵的评论，

点赞加收藏支持我，点击关注，一起进步！

前言

Deque（双端队列）是C++ STL中的一种序列容器，具有以下特点和功能：

双端插入和删除：

可以在队列的两端（前端和后端）进行高效的插入和删除操作，时间复杂度为常量时间。

动态扩展：

与向量（std::vector）类似，Deque可以动态增长以容纳更多元素，并支持自动分配更多内存空间。

随机访问迭代器：

提供了随机访问迭代器，允许通过索引快速访问Deque中的任何元素。

正文

01-Deque容器简要解释

C++中的std::deque（双端队列）是一种序列容器，允许在两端进行高效地插入和删除操作。以下是std::deque容器的详细介绍：

双端队列概述：

双端队列是一种序列容器，类似于向量（std::vector），但允许在队列的两端进行高效地插入和删除操作。
与向量不同，双端队列的插入和删除操作在队列的前端和后端都是常量时间复杂度，而向量只能在末尾进行常量时间的插入和删除。

容器特点：

随机访问迭代器：std::deque 提供了随机访问迭代器，可以通过索引快速访问容器中的元素。
动态扩展：与向量一样，双端队列的大小可以动态增长，当容器满时会自动分配更多的内存空间。
双端操作：可以在队列的前端和后端进行插入和删除操作，使得双端队列在某些情况下比向量更加高效。

成员函数：

push_front(val): 将元素 val 插入到双端队列的前端。
push_back(val): 将元素 val 插入到双端队列的后端。
pop_front(): 删除双端队列的第一个元素。
pop_back(): 删除双端队列的最后一个元素。
front(): 返回双端队列的第一个元素的引用。
back(): 返回双端队列的最后一个元素的引用。
size(): 返回双端队列中元素的数量。
empty(): 检查双端队列是否为空。
clear(): 清空双端队列中的所有元素。

使用场景：

当需要在队列的两端频繁地插入和删除元素时，双端队列是一个比较合适的选择。
双端队列通常用于需要快速插入和删除元素的情况，例如实现双端队列数据结构、广度优先搜索等算法中。

总之，std::deque提供了一种灵活高效的双端队列实现，适用于需要频繁在队列两端进行插入和删除操作的场景。

#include <iostream>
#include <deque>

int main() {
    // 创建一个空的双端队列 deque
    std::deque<int> deque;

    // 在队列的前端和后端插入元素
    deque.push_back(1);    // deque: [1]
    deque.push_front(2);   // deque: [2, 1]
    deque.push_back(3);    // deque: [2, 1, 3]

    // 访问队列的第一个和最后一个元素
    std::cout << "Front element: " << deque.front() << std::endl;  // 输出: 2
    std::cout << "Back element: " << deque.back() << std::endl;    // 输出: 3

    // 弹出队列的第一个和最后一个元素
    deque.pop_front();     // deque: [1, 3]
    deque.pop_back();      // deque: [1]

    // 检查队列是否为空和获取队列的大小
    if (!deque.empty()) {
        std::cout << "Deque is not empty." << std::endl;
        std::cout << "Size of deque: " << deque.size() << std::endl;  // 输出: 1
    }

    // 清空队列
    deque.clear();         // deque: []

    // 再次检查队列是否为空
    if (deque.empty()) {
        std::cout << "Deque is empty now." << std::endl;
    }

    return 0;
}

02-Deque容器介绍

C++中的std::deque（双端队列）是一种序列容器，当需要在队列两端频繁地插入和删除元素时，Deque是比较合适的选择。可用于实现双端队列数据结构、广度优先搜索等算法中需要双端操作的情况。总结而言，std::deque提供了一种灵活、高效的双端队列实现，适用于需要在队列两端进行频繁插入和删除操作的场景。

下面给出具体代码分析应用过程：

这段代码演示了如何使用std::deque容器（双端队列）进行元素的插入和遍历操作。下面是对这段代码的详细解释：

包含头文件及命名空间声明：
- #include <iostream>：包含输入输出流的头文件。
- using namespace std;：使用命名空间 std。
函数定义：
- printDeque函数：接受一个std::deque<int>的常量引用作为参数，用于打印该双端队列中的元素。函数内部使用const_iterator类型的迭代器来循环遍历双端队列，使用const修饰确保在函数内不会修改容器中的元素。
- test01函数：在函数内部创建一个空的双端队列 d1，然后使用push_back（尾插法）向队尾插入 0 到 9 十个整数。同时，也提供了push_front（头插法）的方式注释在函数内，向队首插入相同的数据。
遍历并打印双端队列元素：
- 在test01函数中，调用printDeque函数打印双端队列 d1 中的所有元素。
main函数：
- 在main函数中调用test01函数来执行整个测试过程。
- system("pause");：在Windows系统下暂停控制台窗口，等待用户输入任意键后关闭窗口。
- return 0;：返回程序执行成功的标志。

总的来说，这段代码展示了如何创建std::deque容器并通过尾插法向其中插入数据，然后通过printDeque函数遍历并打印双端队列中的元素。最后在main函数中进行调用，展示了std::deque的基本使用方法。

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


void printDeque(const deque<int>&d)   // 加const防止写操作，那么迭代器那里必须使用const_iterator  const迭代器
{
	for (deque<int>::const_iterator it = d.begin(); it != d.end();it++)
	{
		// *it = 100;   容器中数据不可修改
		cout << *it <<" ";
	}
	cout << endl;
}

void test01()
{

	deque<int>d1;

	for (int i = 0; i < 10;i++)
	{
		d1.push_back(i);   // 尾插法 0，1，2，3，4，5，6，7，8，9
//		d1.push_front(i);   // 头插法，9，8，7，6，5，4，3，2，1，0

	}
	printDeque(d1);


}


int main() {

	test01();

	system("pause");
	return 0;
}

运行结果如下图所示：

03-Deque容器排序

代码演示如下，这段代码演示了如何使用 std::deque 容器进行排序操作，包括手动实现的冒泡排序和使用标准库提供的 sort 函数进行排序。以下是对代码的详细解释：

包含头文件及命名空间声明：
- #include <iostream>：包含输入输出流的头文件。
- using namespace std;：使用命名空间 std。
- #include <deque>：包含双端队列 std::deque 的头文件。
- #include <algorithm>：包含标准库算法的头文件，这里用于使用 sort 函数。
函数定义：
- printDeque 函数：接受一个 std::deque<int> 的常量引用作为参数，用于打印该双端队列中的元素。函数内部使用 const_iterator 类型的迭代器来循环遍历双端队列，保证不修改容器中的元素。
- BubbleSort 函数：实现了冒泡排序算法，接受一个 std::deque<int> 的非常量引用作为参数，在函数内部通过交换元素来实现排序。
测试函数 test01：
- 在函数内部创建了一个空的 std::deque<int>，并依次使用 push_back 和 push_front 方法插入几个整数元素。
- 调用 printDeque 函数，打印未排序前的双端队列元素。
- 调用 BubbleSort 函数，对双端队列进行冒泡排序。
- 再次调用 printDeque 函数，打印冒泡排序后的结果。
- 使用 std::sort 函数对双端队列进行排序（默认升序），并再次调用 printDeque 打印排序后的结果。
主函数 main：
- 在 main 函数中调用 test01 函数，执行测试排序功能。
- system("pause");：在Windows系统下暂停控制台窗口，等待用户输入任意键后关闭窗口。
- return 0;：返回程序执行成功的标志。

总结来说，这段代码展示了如何使用 std::deque 容器进行排序操作，包括手动实现的冒泡排序和使用标准库提供的 sort 函数进行排序，同时也展示了如何遍历打印双端队列中的元素。

#include <iostream>
using namespace std;
#include <deque>
#include <algorithm>    // 使用所有算法都要包含这个头文件

// deque排序操作

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

void BubbleSort(deque<int>&d1)    // 这如果加了const，就无法对数据进行交换数字操作了
{
	for (int i = 0; i < d1.size()-1;i++)
	{
		for (int j = 0; j < d1.size() - i - 1;j++)
		{
			if (d1[j]>d1[j+1])
			{
				int temp = d1[j];
				d1[j] = d1[j + 1];
				d1[j + 1] = temp;
			}
		}
	}
}

void test01()
{
	deque<int>d1;
	d1.push_back(10);
	d1.push_back(20);
	d1.push_back(30);
	d1.push_front(200);
	d1.push_front(300);

	cout << "排序前" << endl;
	printDeque(d1);

	// 1、使用冒泡排序交换
	BubbleSort(d1);
	cout << "冒泡排序交换后" << endl;
	printDeque(d1);

	// 2、使用sort排序
	sort(d1.begin(), d1.end());   // 默认从小到达排序
	cout << "sort排序交换后" << endl;
	printDeque(d1);

}


int main() {
	test01();

	system("pause");
	return 0;
}

示例运行结果如下图所示：

04-Deque容器案例-评委打分

代码演示如下，这段代码是一个简单的程序，用于创建五个学生对象并打印它们的姓名和分数。下面是对这段代码的详细解释和分析：

包含头文件及命名空间声明：
- #include <iostream>：包含输入输出流的头文件。
- using namespace std;：使用命名空间 std。
- #include <string>：包含字符串类的头文件。
- #include <vector>：包含向量（动态数组）类的头文件。
类定义：
- class Person：定义了一个名为 Person 的类，用于代表一个学生。
  - Person(string name, int score)：构造函数，用于初始化学生的姓名和分数。
  - string m_Name;：学生的姓名。
  - int m_Score;：学生的分数。
函数定义：
- void creatPerson(vector<Person>&v)：函数用于创建五个学生对象并添加到向量 v 中。
  - 使用 for 循环创建五个学生对象。
  - 在循环内部，通过拼接字符串 nameSeed 中的字符来生成学生的姓名。
  - 初始化每个学生的分数为 0。
  - 创建 Person 对象并将其添加到向量 v 中。
主函数 main：
- 在 main 函数中，首先创建一个向量 v 用于存放学生对象。
- 调用 creatPerson 函数，将创建的学生对象添加到向量 v 中。
- 使用一个 for 循环遍历向量 v 中的每个学生对象，并打印它们的姓名和分数。
- system("pause");：在Windows系统下暂停控制台窗口，等待用户输入任意键后关闭窗口。
- return 0;：返回程序执行成功的标志。

这段代码的作用是创建五个学生对象，每个学生有一个姓名和一个分数，然后将这些学生对象添加到一个向量中，并打印它们的信息。程序没有实现去除最高分和最低分并计算平均分的功能，这一部分需要进一步实现。

#include <iostream>
using namespace std;
#include <string>
#include <vector>
// 要求 有5名选手：选手ABCDE，10个评委分别对每一名选手打分，去除最高分，去除评委中最低分，取平均分。

class Person
{
public:

	Person(string name, int score)
	{
		this->m_Name = name;
		this->m_Score = score;
	}
	
	string m_Name; //姓名
	int m_Score; //平均分
};

void creatPerson(vector<Person>&v)
{
	string nameSeed = "ABCDE";
	for (int i = 0; i < 5;i++)
	{
		
		string name = "学生";
		name += nameSeed[i];
		
		int score = 0;

		Person p (name, score);

		v.push_back(p);
		
	}

}


int main() {

	// 创建容器存放学生
	vector<Person>v;
	creatPerson(v);

	for (vector<Person>::iterator it = v.begin(); it != v.end();it++)
	{
		cout << "名字：" << (*it).m_Name << "分数：" << (*it).m_Score << endl;
	}



	system("pause");
	return 0;
}

运行结果如下图所示：

总结

在C++中，deque（双端队列）是标准模板库中的一种序列容器，具有以下特点和总结：

双端插入和删除：

deque 允许在队列的两端（前端和后端）进行高效的插入和删除操作，时间复杂度为常量时间。

动态扩展：

类似于向量（std::vector），deque 可以动态增长以容纳更多元素，并支持自动分配更多内存空间。

随机访问迭代器：

deque 提供了随机访问迭代器，允许通过索引快速访问 deque 中的任何元素。

成员函数：

push_front(val): 将元素 val 插入到 deque 的前端。
push_back(val): 将元素 val 插入到 deque 的后端。
pop_front(): 删除 deque 的第一个元素。
pop_back(): 删除 deque 的最后一个元素。
front(): 返回 deque 的第一个元素的引用。
back(): 返回 deque 的最后一个元素的引用。
size(): 返回 deque 中元素的数量。
empty(): 检查 deque 是否为空。
clear(): 清空 deque 中的所有元素。

使用场景：

当需要在队列两端频繁地插入和删除元素时，deque 是比较合适的选择。
可用于实现双端队列数据结构、广度优先搜索等算法中需要双端操作的情况。

总体而言，deque 提供了一种灵活、高效的双端队列实现，适用于需要在队列两端进行频繁插入和删除操作的场景。