Artigo Diretório
Prefácio
Hoje é 30 de setembro e amanhã é o Dia Nacional. Antes do feriado, irei organizar o conteúdo do contêiner C ++ que aprendi esta semana. Esta semana eu aprendi sobre o contêiner deque. Deque é um array de duas extremidades que pode inserir e excluir o head end. As funções do contêiner deque específico são organizadas da seguinte forma:
Um, o conceito básico de deque container
1. Função: Matriz de dupla extremidade, que pode inserir e excluir a extremidade da cabeça, que é muito flexível e pode ser usada com flexibilidade de acordo com a situação real.
2. A diferença entre deque e vetor: O
vetor é ineficiente para a inserção e exclusão do cabeçalho, quanto maior o volume de dados, menor a eficiência.
Relativamente falando, deque insere e exclui a cabeça mais rápido do que o vetor.
O vetor acessa os elementos mais rápido do que o deque.
3. Diagrama esquemático interno:
4. O princípio de funcionamento do
deque : Há um controlador central dentro do deque, que mantém o conteúdo de cada buffer, e os dados reais são armazenados no buffer.
O controlador central mantém o endereço de cada buffer, fazendo com que pareça um espaço de memória contínuo ao usar o deque.
O iterador do contêiner deque também suporta acesso aleatório.
Dois, construtor deque
1. Descrição da função:
Deque container structure.
2. Protótipo de função:
deque<T> deqT; 默认构造形式
deque(beg,end); 构造函数将[beg,end)区间中元素拷贝给本身
deque(n,elem); 构造函数将n个elem拷贝给本身
deque(const deque &deq); 拷贝构造函数
3. Exemplo de demonstração de código:
#include<iostream>
using namespace std;
#include<deque>
//deque 构造函数
void printDeque(deque<int>&d)
{
for(deque<int>::iterator it =d.begin();it!=d.end();it++)
{
//*it=100;//将*it重新赋值为100，则会输出10个100
cout<<*it<<" ";
}
cout<<endl;
}
void test01()
{
//默认构造形式
deque<int>dl;
for(int i=0;i<10;i++)
{
dl.push_back(i);
}
printDeque(dl);
//构造函数将[beg,end)区间中的元素拷贝给本身
deque<int>d2(dl.begin(),dl.end());
printDeque(d2);
//构造函数将n个elem拷贝给本身
deque<int>d3(10,100);
printDeque(d3);
//拷贝构造函数
deque<int>d4=d3;
printDeque(d4);
//总结：deque容器和vector容器的构造方式几乎一致，灵活使用即可
}
int main()
{
test01();
system("pause");
return 0;
}
3. Operação de atribuição de deque
1. Descrição da função:
Atribuir valores ao recipiente deque.
2. Protótipo de função:
deque& operator=(const deque &deq); 重载等号操作符
assign(beg,end); 将[beg,end)区间中的数据拷贝赋值给本身
assign(n,elem); 将n个elem拷贝赋值给本身
3. Exemplo de demonstração de código:
#include<iostream>
using namespace std;
#include<deque>
void printDeque(const deque<int>&d)
{
for(deque<int>::const_iterator it =d.begin();it!=d.end();it++)
{
cout<<*it<<" ";
}
cout<<endl;
}
//deque容器赋值操作
void test01()
{
deque<int>dl;
for(int i=0;i<10;i++)
{
dl.push_back(i);
}
printDeque(dl);
//operator= 赋值
deque<int>d2;
d2=dl;
printDeque(d2);
//assign赋值
deque<int>d3;
d3.assign(dl.begin(),dl.end());
printDeque(d3);
deque<int>d4;
d4.assign(10,100);
printDeque(d4);
//总结：deque赋值操作也与vector相同，需熟练掌握
}
int main()
{
test01();
system("pause");
return 0;
}
4. Operação de redução de tamanho
1. Descrição da função:
Operar o tamanho do recipiente deque.
2. Protótipo de função:
deque.empty(); 判断容器是否为空
deque.size(); 返回容器中元素的个数
deque.resize(num); 重新指定容器的长度为num，若容器变长，则默认值填充新位置，
若容器变短，则末尾值超出容器长度的元素被删除
deque.resize(num,elem); 重新指定容器的长度为num,若容器边长，则以elem值填充新位置，
如果容器变短，则末尾超出容器长度的元素被删除
3. Exemplo de demonstração de código:
#include<iostream>
using namespace std;
#include<deque>
//deque容器大小操作
void printDeque(const deque<int>&d)
{
for(deque<int>::const_iterator it = d.begin();it!=d.end();it++)
{
cout<<*it<<" ";
}
cout<<endl;
}
void test01()
{
deque<int>dl;
for(int i=0;i<10;i++)
{
dl.push_back(i);
}
printDeque(dl);
if(dl.empty())
{
cout<<"dl为空："<<endl;
}
else
{
cout<<"dl不为空："<<endl;
cout<<"dl的大小为："<<dl.size()<<endl;
//deque容器没有容量概念
}
//重新指定大小
//dl.resize(15);
dl.resize(15,2);
printDeque(dl);
/*总结：deque没有容量的概念
判断是否为空 --- empty
返回元素个数 --- size
重新指定个数 --- resize*/
}
int main()
{
test01();
system("pause");
return 0;
}
5. Deque a inserção e exclusão
1. Descrição da função:
inserir e excluir dados no recipiente deque
2. Protótipo de função:
两端插入操作：
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）区间的数据，无返回值
clear(); 清空容器的所有数据
erase(beg,end); 删除[beg,end)区间的数据，返回下一个数据的位置
erase(pos); 删除pos位置的数据，返回下一个数据的位置
3. Exemplo de código específico:
#include<iostream>
using namespace std;
#include<deque>
//deque容器插入和删除
void printDeque(const deque<int>&d)
{
for(deque<int>::const_iterator it=d.begin();it!=d.end();it++)
{
cout<<*it<<" ";
}
cout<<endl;
}
//两端操作
void test01()
{
deque<int>dl;
//尾插
dl.push_back(10);
dl.push_back(20);
//头插
dl.push_front(100);
dl.push_front(200);
printDeque(dl);
//尾删
dl.pop_back();
//200 100 10
printDeque(dl);
//头删
dl.pop_front();
//100 10
printDeque(dl);
//insert插入
dl.insert(dl.begin(),1000);
dl.insert(dl.end(),1000);
printDeque(dl);
dl.insert(dl.begin(),2,10000);
//10000 10000 1000 100 10 1000
printDeque(dl);
//按照区间进行插入
deque<int>d2;
d2.push_back(1);
d2.push_back(2);
d2.push_back(3);
dl.insert(dl.begin(),d2.begin(),d2.end());
//1,2,3,10000,10000,1000,100,10,1000
printDeque(dl);
}
void test02()
{
deque<int>dl;
dl.push_back(10);
dl.push_back(20);
dl.push_back(100);
dl.push_back(200);
//删除
deque<int>::iterator it = dl.begin();
it++;
dl.erase(it);
//100 10 20
printDeque(dl);
//按区间的方式删除
dl.erase(dl.begin(),dl.end());
//清空
dl.clear();
printDeque(dl);
}
int main()
{
//test01();
test02();
system("pause");
return 0;
}
6, acesso a dados deque
1. Descrição da função:
acesso aos dados em deque
2. Protótipo de função:
at(int idx); 返回索引idx所指的数据
operator[]; 返回索引idx所指的数据
front(); 返回容器中第一个数据
back(); 返回容器中最后一个数据
3. Exemplo de código específico:
#include<iostream>
using namespace std;
#include<deque>
//deque容器数据存取
void test01()
{
deque<int>d;
d.push_back(10);
d.push_back(20);
d.push_back(30);
d.push_front(100);
d.push_front(200);
d.push_front(300);
//通过[]方式访问元素
//300 200 100 10 20 30
int i;
for(i=0; i<d.size() ;i++);
{
cout<<d[i]<<" ";
}
cout<<endl;
//通过at方式访问元素
for(i=0; i<d.size() ;i++)
{
cout<<d.at(i)<<" ";
}
cout<<endl;
}
int main()
{
test01();
system("pause");
return 0;
}
7, classificação do recipiente deque
1. Descrição da função:
use o algoritmo para classificar o recipiente deque
2. Algoritmo:
sort(iterator beg,iterator end) 对beg和end区间内元素进行排序
3. Exemplo de código específico:
#include<iostream>
using namespace std;
#include<deque>
#include<algorithm> //标准算法头文件
void printDeque(const deque<int>&d)
{
for(deque<int>::const_iterator it =d.begin();it!=d.end();it++)
{
cout<<*it<<" ";
}
cout<<endl;
}
//deque容器排序
void test01()
{
deque<int>d;
d.push_back(10);
d.push_back(10);
d.push_back(10);
d.push_front(100);
d.push_front(200);
d.push_front(300);
//300 200 100 10 20 30
printDeque(d);
//排序 默认排序规则 从小到大 升序
//对于支持随机访问的迭代器的容器，都可以利用sort算法直接对其进行排序
//vector容器也可以利用 sort进行排序
sort(d.begin(),d.end());
cout<<"排序后："<<endl;
printDeque(d);
}
int main()
{
test01();
system("pause");
return 0;
}
Resumindo
O exposto acima é o conteúdo relacionado ao contêiner deque, a partir do conceito básico do contêiner deque, o construtor deque. Específico para operações de atribuição de deque, operações de tamanho de deque, inserção e exclusão de deque, acesso de dados deque, classificação de container deque e outras funções específicas, o deque tem funções muito práticas.
Depois de resolver isso hoje, sinto que entendo mais sobre o contêiner deque. Ainda tenho que pensar mais, praticar mais e continuar a trabalhar duro (ง • _ •) ง