黑马c++ STL部分 笔记(3) deque容器

简介: 黑马c++ STL部分 笔记(3) deque容器

双端数组,可以对头端进行插入删除操作

deque与vector区别:

vector对于头部的插入删除效率低,数据量越大,效率越低(每次头插,后面的元素就往后移)

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

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

88e146ba8de0472f9f5dd501f29fb506.jpg

deque内部工作原理:

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

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

7faf63d00bc14336ab1dd73ca1f95169.jpg

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

1.deque的构造函数

// deque构造函数
/*
功能描述:
deque容器构造
函数原型:
deque<T> deqT; //默认构造形式
deque(beg, end); //构造函数将[beg, end)区间中的元素拷贝给本身。
deque(n, elem); //构造函数将n个elem拷贝给本身。
deque(const deque &deq); //拷贝构造函数
*/
#include <bits/stdc++.h>
using namespace std;
void printdeque(deque<int> &d)
{
  for (deque<int>::iterator it = d.begin(); it != d.end(); it++)
  {
    //*it=100;//每个值都改为100,若只读,则deque<int> 改为const deque<int>即可,即容器中只读
    cout << *it << " ";
  }
  cout << endl;
}
void test01()
{
  deque<int> d1; // 默认构造
  for (int i = 0; i < 10; i++)
  {
    d1.push_back(i);
  }
  printdeque(d1);                      // 0 1 2 3 4 5 6 7 8 9
  deque<int> d2(d1.begin(), d1.end()); // 区间构造
  printdeque(d2);                      // 0 1 2 3 4 5 6 7 8 9
  deque<int> d3(3, 100);               // n个element
  printdeque(d3);                      // 100 100 100
  deque<int> d4(d3);                   // 拷贝构造
  printdeque(d4);                      // 100 100 100
}
 
int main()
{
  test01();
}
/*
总结:deque容器和vector容器的构造方式几乎一致,灵活使用即可
*/


2.deque赋值操作

// deque赋值操作
/*
功能描述:
给deque容器进行赋值
函数原型:
deque& operator=(const deque &deq); //重载等号操作符
assign(beg, end); //将[beg, end)区间中的数据拷贝赋值给本身。
assign(n, elem); //将n个elem拷贝赋值给本身。
*/
#include <bits/stdc++.h>
using namespace std;
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); // 0 1 2 3 4 5 6 7 8 9
  deque<int> d2;
  d2 = d1;        //=赋值
  printdeque(d2); // 0 1 2 3 4 5 6 7 8 9
  deque<int> d3;
  d3.assign(d1.begin(), d1.begin() + 3); // assign  (左闭右开)
  printdeque(d3);                        // 0 1 2
  deque<int> d4;
  d4.assign(3, 100); // assign,n个element
  printdeque(d4);    // 100 100 100
}
 
int main()
{
  test01();
}
/*
总结:deque赋值操作也与vector相同,需熟练掌握
*/


3.deque大小操作

// deque大小操作
/*
功能描述:
对deque容器的大小进行操作
函数原型:
deque.empty(); //判断容器是否为空
deque.size(); //返回容器中元素的个数
deque.resize(num); //重新指定容器的长度为num
若容器变长,则以默认值0填充新位置。
若容器变短,则末尾超出容器长度的元素被删除。
deque.resize(num, elem); //重新指定容器的长度为num,
若容器变长,则以elem值填充新位置。
若容器变短,则末尾超出容器长度的元素被删除。
*/
#include <bits/stdc++.h>
using namespace std;
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); // 0 1 2 3 4 5 6 7 8 9
  if (d1.empty())
  {
    cout << "d1为空" << endl;
  }
  else
  {
    cout << "d1不为空" << endl;
    cout << "d1的大小:" << d1.size() << endl; // 10
    // 无d1.capacity,因为可以无限放数据,与其结构有关
  }
  // 重新指定大小
  d1.resize(15);
  printdeque(d1); // 0 1 2 3 4 5 6 7 8 9 0 0 0 0 0
  d1.resize(16, 111);
  printdeque(d1); // 0 1 2 3 4 5 6 7 8 9 0 0 0 0 0 111
  d1.resize(5);
  printdeque(d1); // 0 1 2 3 4
}
 
int main()
{
  test01();
}
/*
总结:
deque没有容量的概念,vector有
判断是否为空 — empty
返回元素个数 — size
重新指定个数 — resize
*/


4.deque 插入和删除

// deque 插入和删除
/*
功能描述:
向deque容器中插入和删除数据
函数原型:
--两端插入操作:
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位置的数据,返回下一个数据的位置。
*/
#include <bits/stdc++.h>
using namespace std;
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;
  // 尾插
  d1.push_back(1);
  d1.push_back(2);
  d1.push_back(3);
  printdeque(d1); // 1 2 3
  // 头插
  d1.push_front(100);
  d1.push_front(200);
  d1.push_front(300);
  printdeque(d1); // 300 200 100 1 2 3
  // 尾删
  d1.pop_back();
  printdeque(d1); // 300 200 100 1 2
  // 头删
  d1.pop_front();
  printdeque(d1); // 200 100 1 2
  // 两端操作
  // insert
  d1.insert(d1.begin() + 1, 1000); // pos为迭代器
  printdeque(d1);                  // 200 1000 100 1 2
  d1.insert(d1.begin(), 2, 111);
  printdeque(d1); // 111 111 200 1000 100 1 2
  // 在指定位置插入区间
  deque<int> d2;
  d2.push_back(1);
  d2.push_back(2);
  d2.push_back(3);
  d1.insert(d1.begin(), d2.begin(), d2.end());
  printdeque(d1); // 1 2 3 111 200 1000 100 1 2
  // 删除
  d1.erase(d1.begin());               // 删除pos位置
  printdeque(d1);                     // 2 3 111 200 1000 100 1 2
  d1.erase(d1.begin() + 1, d1.end()); // 删除区间元素
  printdeque(d1);                     // 2
  int main()
  {
    test01();
  }
  /*
  总结:
  插入和删除提供的位置是迭代器!
  尾插 — push_back
  尾删 — pop_back
  头插 — push_front
  头删 — pop_front
  */


5.deque 数据存取

// deque 数据存取
/*
功能描述:
对deque 中的数据的存取操作
函数原型:
at(int idx); //返回索引idx所指的数据
operator[]; //返回索引idx所指的数据
front(); //返回容器中第一个数据元素
back(); //返回容器中最后一个数据元素
*/
#include <bits/stdc++.h>
using namespace std;
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);
  // 通过[]
  for (int i = 0; i < d.size(); i++)
  {
    cout << d[i] << " "; // 300 200 100 10 20 30
  }
  cout << endl;
  // 通过at
  for (int i = 0; i < d.size(); i++)
  {
    cout << d.at(i) << " "; // 300 200 100 10 20 30
  }
  cout << endl;
  cout << d.front() << " " << d.back(); // 300 30
}
int main()
{
  test01();
}
/*
总结:
除了用迭代器获取deque容器中元素,[ ]和at也可以
front返回容器第一个元素
back返回容器最后一个元素
*/


6.deque 排序

// deque 排序
/*
功能描述:
利用算法实现对deque容器进行排序
函数原型:
sort(iterator beg, iterator end) //对beg和end区间内元素进行排序
*/
#include <bits/stdc++.h>
using namespace std;
void printdeque(const deque<int> &d)
{
  for (deque<int>::const_iterator it = d.begin(); it != d.end(); it++)
  {
    cout << *it << " ";
  }
  cout << endl;
}
bool cmp(int d1, int d2)
{ // 使sort后按自定义方式排序
  // 例:降序
  if (d1 > d2)
    return true;
  else
    return false;
}
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);
  printdeque(d); // 300 200 100 10 20 30
  sort(d.begin(), d.end());
  printdeque(d); // 10 20 30 100 200 300 sort默认升序
  sort(d.begin(), d.end(), cmp);
  printdeque(d); // 300 200 100 30 20 10 cmp内为降序
}
int main()
{
  test01();
}
/*
总结:
sort算法非常实用,使用时包含头文件 algorithm即可
*/


相关文章
|
3月前
|
存储 搜索推荐 C++
【C++篇】深度剖析C++ STL:玩转 list 容器,解锁高效编程的秘密武器2
【C++篇】深度剖析C++ STL:玩转 list 容器,解锁高效编程的秘密武器
80 2
|
2月前
|
存储 设计模式 C++
【C++】优先级队列(容器适配器)
本文介绍了C++ STL中的线性容器及其适配器,包括栈、队列和优先队列的设计与实现。详细解析了`deque`的特点和存储结构,以及如何利用`deque`实现栈、队列和优先队列。通过自定义命名空间和类模板,展示了如何模拟实现这些容器适配器,重点讲解了优先队列的内部机制,如堆的构建与维护方法。
49 0
|
3月前
|
存储 C++ 容器
【C++篇】深度剖析C++ STL:玩转 list 容器,解锁高效编程的秘密武器1
【C++篇】深度剖析C++ STL:玩转 list 容器,解锁高效编程的秘密武器
81 5
|
3月前
|
存储 编译器 C++
【C++篇】揭开 C++ STL list 容器的神秘面纱:从底层设计到高效应用的全景解析(附源码)
【C++篇】揭开 C++ STL list 容器的神秘面纱:从底层设计到高效应用的全景解析(附源码)
96 2
|
3月前
|
存储 C++ 容器
C++番外篇——stack、queue的实现及deque的介绍
C++番外篇——stack、queue的实现及deque的介绍
36 0
|
3月前
|
设计模式 存储 C++
【C++】C++ STL探索:容器适配器 Stack 与 Queue 的使用及模拟实现(二)
【C++】C++ STL探索:容器适配器 Stack 与 Queue 的使用及模拟实现
|
11天前
|
C++ 芯片
【C++面向对象——类与对象】Computer类(头歌实践教学平台习题)【合集】
声明一个简单的Computer类,含有数据成员芯片(cpu)、内存(ram)、光驱(cdrom)等等,以及两个公有成员函数run、stop。只能在类的内部访问。这是一种数据隐藏的机制,用于保护类的数据不被外部随意修改。根据提示,在右侧编辑器补充代码,平台会对你编写的代码进行测试。成员可以在派生类(继承该类的子类)中访问。成员,在类的外部不能直接访问。可以在类的外部直接访问。为了完成本关任务,你需要掌握。
51 18
|
11天前
|
存储 编译器 数据安全/隐私保护
【C++面向对象——类与对象】CPU类(头歌实践教学平台习题)【合集】
声明一个CPU类,包含等级(rank)、频率(frequency)、电压(voltage)等属性,以及两个公有成员函数run、stop。根据提示,在右侧编辑器补充代码,平台会对你编写的代码进行测试。​ 相关知识 类的声明和使用。 类的声明和对象的声明。 构造函数和析构函数的执行。 一、类的声明和使用 1.类的声明基础 在C++中,类是创建对象的蓝图。类的声明定义了类的成员,包括数据成员(变量)和成员函数(方法)。一个简单的类声明示例如下: classMyClass{ public: int
37 13
|
11天前
|
编译器 数据安全/隐私保护 C++
【C++面向对象——继承与派生】派生类的应用(头歌实践教学平台习题)【合集】
本实验旨在学习类的继承关系、不同继承方式下的访问控制及利用虚基类解决二义性问题。主要内容包括: 1. **类的继承关系基础概念**:介绍继承的定义及声明派生类的语法。 2. **不同继承方式下对基类成员的访问控制**:详细说明`public`、`private`和`protected`继承方式对基类成员的访问权限影响。 3. **利用虚基类解决二义性问题**:解释多继承中可能出现的二义性及其解决方案——虚基类。 实验任务要求从`people`类派生出`student`、`teacher`、`graduate`和`TA`类,添加特定属性并测试这些类的功能。最终通过创建教师和助教实例,验证代码
37 5
|
11天前
|
存储 算法 搜索推荐
【C++面向对象——群体类和群体数据的组织】实现含排序功能的数组类(头歌实践教学平台习题)【合集】
1. **相关排序和查找算法的原理**:介绍直接插入排序、直接选择排序、冒泡排序和顺序查找的基本原理及其实现代码。 2. **C++ 类与成员函数的定义**:讲解如何定义`Array`类,包括类的声明和实现,以及成员函数的定义与调用。 3. **数组作为类的成员变量的处理**:探讨内存管理和正确访问数组元素的方法,确保在类中正确使用动态分配的数组。 4. **函数参数传递与返回值处理**:解释排序和查找函数的参数传递方式及返回值处理,确保函数功能正确实现。 通过掌握这些知识,可以顺利地将排序和查找算法封装到`Array`类中,并进行测试验证。编程要求是在右侧编辑器补充代码以实现三种排序算法
28 5

热门文章

最新文章