C++——deque容器

最新推荐文章于 2024-09-24 16:25:18 发布
最新推荐文章于 2024-09-24 16:25:18 发布
阅读量1k 收藏 4
点赞数 2
分类专栏： C++ 文章标签： c++ 开发语言 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_47207479/article/details/128891910
版权

目录

1，基本概念

2，deque构造函数

3，赋值操作 

4，deque容器大小操作 

5，插入和删除 

6，deque数据存取

7， 排序操作

8，案例-评委打分

1，基本概念

deque: deuble ended queue;

功能：双端数组，可以对头端进行插入删除操作。

deuqe与vector区别：

vector对于头部的插入删除效率低，数据量越大，效率越低；

deque相对而言，对头部的插入删除速度比vector快；

vector访问元素时的速度会比deque快，这和两者内部实现有关。

 deque内部工作原理：

deque内部有个中控器，维护每段缓冲区的内容，缓冲区中存放真实数据；

中控器维护的是每个缓冲区的地址，使得使用deque时像一片连续的内存空间。

 deque容器的迭代器也是支持随机访问的。

2，deque构造函数

功能：deque容器构造；

函数原型：

deque<T> deqT;       //默认构造

deque(beg,end);      //构造函数将[beg,end)区间中的元素拷贝给本身

deque(n,elem);       //构造函数将n个elem拷贝给本身

deque(const deque & deq);    //拷贝构造函数

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

void printDeuqe(const deque<int>& d)
{
	for (deque<int>::const_iterator it = d.begin(); it != d.end(); it++)
	{
		//*it = 100;  增加const后*it不可以被修改
		cout << *it << " ";
	}
	cout << endl;
}

void test01()
{
	deque<int> d1;
	for (int i = 0; i < 10; i++)
	{
		d1.push_back(i);
	}
	printDeuqe(d1);

	deque<int> d2(d1.begin(), d1.end());
	printDeuqe(d2);

	deque<int> d3(5, 100);
	printDeuqe(d3);

	deque<int> d4(d3);
	printDeuqe(d4);
}

int main()
{
	test01();
	system("pause");
	return 0;
}

注意const关键字的影响。 

运行结果：

0 1 2 3 4 5 6 7 8 9
0 1 2 3 4 5 6 7 8 9
100 100 100 100 100
100 100 100 100 100
请按任意键继续. . .

3，赋值操作 

功能：给deque容器进行赋值；

函数原型：

deque& operator=(const deque& deq);    //重载等号操作符

assign(beg,end);       //将[beg,end)区间中的数据拷贝赋值给本身

assign(n,elem);      //将n个elem拷贝赋值给本身 

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

void printDeuqe(const deque<int>& d)
{
	for (deque<int>::const_iterator it = d.begin(); it != d.end(); it++)
	{
		//*it = 100;  增加const后*it不可以被修改
		cout << *it << " ";
	}
	cout << endl;
}

void test01()
{
	deque<int> d1;
	for (int i = 0; i < 10; i++)
	{
		d1.push_back(i);
	}
	printDeuqe(d1);

	deque<int> d2 = d1;
	printDeuqe(d2);

	deque<int> d3;
	d3.assign(d1.begin(), d1.end());
	printDeuqe(d3);

	deque<int> d4(10, 10);
	printDeuqe(d4);

}

int main()
{
	test01();
	system("pause");
	return 0;
}

4，deque容器大小操作 

功能：对deque容器的大小进行操作；

函数原型：

deque.empty();       // 判断容器是否为空

deque.size();        //返回容器中元素的个数

deque.resize(num);     //重新指定容器的长度为num，若容器变长，则默认值填充新位置。如果容器变短，则末尾超出容器长度的元素被删除

deque.resize(num,elem);     //重新指定容器的长度为num，若容器变长，则以elem填充新位置。如果容器变短，则末尾超出容器长度的元素被删除

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

void printDeuqe(const deque<int>& d)
{
	for (deque<int>::const_iterator it = d.begin(); it != d.end(); it++)
	{
		//*it = 100;  增加const后*it不可以被修改
		cout << *it << " ";
	}
	cout << endl;
}

void test01()
{
	deque<int> d1;
	for (int i = 0; i < 10; i++)
	{
		d1.push_back(i);
	}
	
	if (d1.empty())
	{
		cout << "容器为空" << endl;
	}
	else
	{
		cout << "容器不为空" << endl;
		cout << "容器的大小：" << d1.size() << endl;
	}

	//注意deque容器没有容量的概念
	//d1.resize(15);
	//d1.resize(15,100);
	d1.resize(5);
	printDeuqe(d1);

}

int main()
{
	test01();
	system("pause");
	return 0;
}

注意：deque容器没有容量的概念。

5，插入和删除 

功能：向deque容器中插入和删除数据；

函数原型：

两端插入操作

push_back(elem)      //尾部插入一个数据

push_front(elem)     //头部插入一个数据

pop_back(elem)      //尾部删除一个数据

pop_front(elem)     // 头部删除一个数据

指定位置操作：

insert(pos,elem)    //pos位置插入一个elem元素的拷贝，返回新数据的位置

insert(pos,n,elem)  //pos位置插入n个elem数据，无返回值

insert(pos,beg,end)  //在pos位置插入[beg,end)区间的数据，无返回值

clear()          //清空容器的所有数据

erase(beg,end)  //删除[beg,end)区间的数据，返回下一个数据的位置

erase(pos)        //删除pos位置的数据，返回下一个数据的位置

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

void printDeuqe(const deque<int>& d)
{
	for (deque<int>::const_iterator it = d.begin(); it != d.end(); it++)
	{
		//*it = 100;  增加const后*it不可以被修改
		cout << *it << " ";
	}
	cout << endl;
}

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

	printDeuqe(d1);

	d1.pop_back();
	d1.pop_front();
	printDeuqe(d1);

	d1.insert(d1.begin(), 300);
	printDeuqe(d1);

	d1.insert(d1.begin(), 2, 400);
	printDeuqe(d1);

	deque<int> d2;
	d2.insert(d2.begin(),d1.begin(), d1.end());
	printDeuqe(d2);

	d1.erase(d1.begin());
	printDeuqe(d1);

	//d1.erase(d1.begin(), d1.end());
	d1.clear();
	printDeuqe(d1);

}

int main()
{
	test01();
	system("pause");
	return 0;
}

6，deque数据存取

功能：对deque中的数据存取操作；

函数原型：

at(int idx);    //返回索引idx所指的数据

operator[idx];   //返回索引idx所致的数据

front();     //返回容器中第一个数据元素

back();   //返回容器中最后一个数据元素

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

void printDeuqe(const deque<int>& d)
{
	for (deque<int>::const_iterator it = d.begin(); it != d.end(); it++)
	{
		//*it = 100;  增加const后*it不可以被修改
		cout << *it << " ";
	}
	cout << endl;
}

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

	for (int i=0;i<4;i++)
	{
		//[]方式访问
		//cout << d1[i] << " ";
		//at方式访问
		cout << d1.at(i) << " ";
	}
	cout << endl;

	cout << "第一个元素：" << d1.front() << endl;
	cout << "最后一个元素：" << d1.back() << endl;
}

int main()
{
	test01();
	system("pause");
	return 0;
}

7， 排序操作

功能：利用算法实现对deque容器进行排序

函数原型：

sort(iterator beg, iterator end)   // 对beg和end区间内元素进行排序，默认为升序

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

void printDeuqe(const deque<int>& d)
{
	for (deque<int>::const_iterator it = d.begin(); it != d.end(); it++)
	{
		//*it = 100;  增加const后*it不可以被修改
		cout << *it << " ";
	}
	cout << endl;
}

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

	printDeuqe(d1);

	sort(d1.begin(), d1.end());
	cout << "排序后：" << endl;
	printDeuqe(d1);
}

int main()
{
	test01();
	system("pause");
	return 0;
}

运行后：

300 200 100 10 20 30
排序后：
10 20 30 100 200 300
请按任意键继续. . .

注意：sort排序默认规则为从大到小，升序排列，对于支持随机访问的迭代器的容器，都可以用sort算法直接对其进行排序，vector容器也可以利用sort进行排序。

sort算法非常实用，需要包含algorithm头文件。

8，案例-评委打分

案例描述：选手ABCDE，10个评委分别对每一个选手打分，去除最高分和最低分，取平均分。

实现步骤：

1，创建五名选手，放到vector容器中；

2，遍历vector容器，取出来每一个选手，执行for循环，可以把10个评分存到deque容器中；

3，sort算法对deque容器中分数排序，去除最高和最低分；

4，deque容器遍历一遍，累加总分；

5，获取平均分。

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

void printDeuqe(const deque<int>& d)
{
	for (deque<int>::const_iterator it = d.begin(); it != d.end(); it++)
	{
		//*it = 100;  增加const后*it不可以被修改
		cout << *it << " ";
	}
	cout << endl;
}

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);
	}
}

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

void setScore(vector<Person>& v)
{
	for (vector<Person>::iterator it = v.begin(); it != v.end(); it++)
	{
		deque<int> d;
		for (int i=0;i<10;i++)
		{
			int score = rand() % 41 + 60;
			d.push_back(score);
		}

		sort(d.begin(), d.end());
		d.pop_back();
		d.pop_front();

		int sum = 0;
		for (deque<int>::iterator dit = d.begin(); dit != d.end(); dit++)
		{
			sum += *dit;
		}

		int avg = sum / d.size();

		it->m_Score = avg;
	}
}

void test01()
{
	//随机数种子
	srand((unsigned int)time(NULL));

	vector<Person> v;
	creatPerson(v);
	//遍历vector中元素
	//printVector(v);

	//给选手打分
	setScore(v);

	//打印最终得分
	printVector(v);

}

int main()
{
	test01();
	system("pause");
	return 0;
}

以上案例中用到了vector容器和deque容器。 

weixin_47207479
关注
专栏目录
C++ STL顺序容器 —— deque底层实现原理剖析
ZY-JIMMY
05-03 4490
概述 、deque的中控器 、迭代器 、数据结构 、构造与内存管理 、元素操作
笔记（四）——deque容器的基础理论知识
m0_51273315的博客
02-27 112
STL,deque
c++---deque容器
m0_50046535的博客
04-21 668
1、deque容器基本概念 功能：双端数组，可以对头端进行插入删除操作 deque和vector的区别 vector对于头部的插入删除效率低，数据量越大，效率越低 deque相对而言，对头部的插入删除速度会比vector快 vector访问元素时的速度会比deque快，和两者的内部实现有关 2、deque构造函数 函数原型： deque<T> deqT；默认构造函数 deque（beg，end）；构造函数将beg，end区间中的元素拷贝给本身 deque（n，elem.
c++ 之deque
qq_46615150的博客
02-25 2191
文章目录1.deque 的简介示例：2.deque的常用成员函数：示例：3.deque图解4.deque 与 vector 的区别 1.deque 的简介 ①deque 系由一块一块的固定大小的连续空间构成（块与块之间是不连续）。一旦有必要在 deque 的前端或尾端增加新的空间，便配置一块固定大小的连续空间，串接在整个 deque 的头端或尾端。 ②deque 的最大任务，便是在这些分块的固定大小连续空间上，维护其整体连续的假象，并提供随机存取的接口（随机迭代器），代价则是迭代器架构较为复杂。 ③dequ
C++之STL—deque容器
最新发布
QoQ_____________的博客
09-24 368
2. 遍历vector容器，取出来每一个选手，执行for循环，可以把10个评分打分存到deque容器中。有5名选手：选手ABCDE，10个评委分别对每一名选手打分，去除最高分，去除评委中最低分，取平均分。* 头插 --- push_front。* 重新指定个数 --- resize。* 尾插 --- push_back。* 头删 --- pop_front。* 判断是否为空 --- empty。* 尾删 --- pop_back。* 返回元素个数 --- size。
C++ deque
学不可以已的博客
04-15 283
deuque
C++ deque
柯拉的博客
04-20 434
deque 可以同时向两端增长。与vector 有相似地接口 #include <iostream> #include <deque> using namespace std; int main() { deque<int> deq = { 1,2,3 }; deq.push_front(4); //在 队列地开端进行插入 deq.pu...
C ++ deque
天启的博客
08-10 481
1.简介 deque是一个双端队列，内容保存在堆中，支持随即访问和快速插入删除，在容器中某一位置上的操作所花费的是线性时间。它的保存形式为： 堆1 堆2 堆3 每个堆保存好几个元素，堆和堆之间有指针指向。 使用时添加头文件#include<deque> 2.声明 deque<int> c;//创建一个空的 dequedeque<int> c1(c2);//将c2的内容复制到c1 deque<int> c1(n);//创建一个deque，含有n
C++ STL容器 —— deque 用法详解
Ember_Sky
04-24 1201
C++ STL容器—— deque 函数用法详解 写在前面：近期正在重新学习C++的STL容器，因此准备用一些大白话将STL函数的用法详细记录一下，主要介绍一些基本函数的用法, 外加实际的例子，并不涉及原理。其实最好的方法还是需要自己上手操作一下. 写的不好, 请大神手下留情. 下面说的 “运行之后” 表示: 运行上个语句之后的结果. 一行如果说的太长的话, 就得拖动下面的进度条才能看到后面的...
STL——deque容器
weixin_45149964的博客
10-18 168
功能：双端数组，可以对头端进行插入删除操作 deque与vector区别： 1.vector对于头部的插入删除效率低，数据量越大，效率越低 2.deque相对而言，对头部的插入删除速度比vector快 3.vector访问元素时的速度比deque快，这是因为两者的内部实现不同 deque内部工作原理： 内部有中控器，维护每段缓冲区中的内容，缓冲区中存放真实数据 中控器维护的是每个缓冲区的地址，使得使用deque时像一片连续的内存空间 deque容器的迭代器也是支持随机访问 de
每天学点C++（C++实例教程：教程+源码）01deque容器.zip
06-21
本教程聚焦于C++中的一个特定容器——deque（双端队列），它是C++标准模板库（STL）的一部分。 deque，全称Double Ended Queue，是一种线性容器，它允许在两端进行高效地插入和删除操作。与数组类似，deque可以随机...
C++——deque
qwjy的博客
04-17 8777
  文章目录Deque 与 vector 的异同点构造操作非更易型操作更易型操作使用例子       容器 deque (发音为“deck”)和 vector 非常相似。它也采用dynamic array来管理元素，提供随机访问，并有着和 vector 几乎一模一样的接口。不同的是 deque 的 dynamic array 头尾都开放，因此能在头尾两端进行快速安插和删除（如下图所示)。 为了提供这种能力， deque 通常实现为一组独立区块，第一区块朝某方向扩展，最末区块朝
C++ Deque的使用
windistance的博客
09-02 6901
文章目录1、前言2、初始化3、基本操作deq.size()-容器大小deq.max_size()-容器最大容量deq.resize()-更改容器大小deq.empty()-容器判空deq.shrink_to_fit()-减少容器大小到满足元素所占存储空间的大小push_back-尾部增加元素push_front-前端增加元素pop_back-删除尾部元素pop_front-删除前端元素emplac...
c++deque容器
tulipless的博客
07-20 552
#define _CRT_SECURE_NO_WARNINGS #include &lt;iostream&gt; #include &lt;deque&gt; #include &lt;vector&gt; #include &lt;string&gt; #include &lt;algorithm&gt; using namespace std;   class Player ...
C++ deque 容器
雪剑封心
02-03 128
【代码】C++ deque 容器。
C++ deque容器
technologyleader的专栏
07-08 330
c++ deque
deque
pzhw520wlim的博客
06-07 320
C++ Deque(双向队列)     是一种优化了的、对序列两端元素进行添加和删除操作的基本序列容器。它允许较为快速地随机访问，但它不像vector 把所有的对象保存在一块连续的内存块，而是采用多个连续的存储块，并且在一个映射结构中保存对这些块及其顺序的跟踪。向deque 两端添加或删除元素的开销很小。它不需要重新分配空间，所以向末端增加元素比vector 更有效。     实际上，
《STL学习笔记》 -- deque容器
ccr的博客
05-09 348
一、概念 功能： 双端数组，可以对头端进行插入删除等操作。 deque与vector区别： vector对于头部的插入删除效率低，数据量越大，效率越低。 deque相对而言，对头部的插入删除速度回比vector快。 deque容器的迭代器也是支持随机访问的。 vector访问元素时的速度会比deque快,这和两者内部实现有关。 deque的内部工作原理： deque内部有个中控器，维护每段缓冲区中的内容，缓冲区中存放真实数据 中控器维护的是每个缓冲区的地址，使得使用deque时像一片.
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值