conteneur décalé
Concept de base du conteneur deque
Fonction:
tableau à double extrémité, qui peut effectuer des opérations d'insertion et de suppression sur la tête de réseau. La
différence entre deque et vector est
que l'efficacité d'insertion et de suppression du vecteur est faible pour la tête. Plus le volume de données est important, plus l'efficacité est faible .
Deque est relativement plus rapide que vector pour l'insertion et la suppression de la tête
Vector accède aux éléments plus rapidement que deque, ce qui est lié à l'implémentation interne des deux. Le
principe de fonctionnement interne de deque :
Il y a un contrôleur central à l'intérieur de deque, qui maintient le contenu de chaque tampon et stocke les données réelles dans le tampon. Le
contrôleur central maintient C'est l'adresse de chaque tampon, de sorte que lors de l'utilisation de deque
, les itérateurs prennent également en charge l'accès aléatoire
Remarque : j'ai appris cela à cause de la structure des données, donc je viens de finir d'apprendre la liste chaînée, donc je suis un peu confus quand je vois cela. Cependant, une phrase dans le barrage m'a inspiré, disant que deque est une liste chaînée + un tableau
constructeur deque
Description de la fonction : prototype de la fonction
de construction de conteneur deque
:
deque<T> deqT; //默认构造形式
deque(beg,end); //构造函数将[beg,end)区间中的元素拷贝给本身
deque(n,elem); //构造函数将n个elem拷贝给本身
deque(const deque &deq); //拷贝构造函数
#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>d1;
for (int i = 0; i < 10; i++)
{
d1.push_back(i);
}
printDeque(d1);
deque<int>d2(d1.begin(), d1.end());
printDeque(d2);
deque<int>d3(10, 33);
printDeque(d3);
deque<int>d4(d3);
printDeque(d4);
}
int main()
{
test01();
return 0;
}
Résumé : Les méthodes de construction du conteneur deque et du conteneur vector sont presque les mêmes et peuvent être utilisées de manière flexible
opération d'affectation deque
Description de la fonction :
attribuer une valeur au conteneur deque
Prototype de fonction :
deque& operator=(const deque &deq); //重载等号操作符
assign(beg,end); //将[beg,end)区间中的数据拷贝赋值给本身
assign(n,elem); //将n个elem拷贝赋值给本身
#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>d1;
for (int i = 0; i < 10; i++)
{
d1.push_back(i);
}
printDeque(d1);
//operator=赋值
deque<int>d2;
d2 = d1;
printDeque(d2);
//assign赋值
deque<int>d3;
d3.assign(d1.begin(), d1.end());
printDeque(d3);
deque<int>d4;
d4.assign(10, 88);
printDeque(d4);
}
int main()
{
test01();
return 0;
}
Résumé : L'opération d'affectation de deque est également identique à celle du vecteur et doit être maîtrisée
opération de taille deque
Description de la fonction :
opérer sur la taille du conteneur deque
Prototype de fonction :
deque.empty(); //判断容器是否为空
deque.size(); //返回容器中元素的个数
deque.resize(); //重新指定容器的长度为num，若容器变长，则以默认值填充新位置。
//如果容器变短，则末尾超出容器长度的元素被删除
deque.resize(num,elem); //重新指定容器的长度为num，若容器变长，则以elem值填充新位置。
//如果容器变短，则末尾超出容器长度的元素被删除
#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>d1;
for (int i = 0; i < 10; i++)
{
d1.push_back(i);
}
printDeque(d1);
if (d1.empty())
{
cout << "d1为空" << endl;
}
else
{
cout << "d1不为空" << endl;
cout << "d1的大小为：" << d1.size() << endl;
//deque容器没有容量概念，这和它内部结构有关
}
//重新指定大小
d1.resize(15);
printDeque(d1);
d1.resize(18,1);
printDeque(d1);
d1.resize(5);
printDeque(d1);
}
int main()
{
test01();
return 0;
}
Résumé :
Deque n'a pas de concept de capacité
. Déterminez s'il est vide : vide
renvoie le nombre d'éléments. La taille
respécifie le nombre. Redimensionnez