关于STL模板

目录

  1. vector

  2. stack

  3. queue

  4. map

  5. set

  6. list

  7. 迭代器

vector

  1. 向量属于顺序容器,用于容纳不定长线性序列(即线性群体),提供对序列的快速随机访问(也称直接访问)
  1. 数据结构很像一个数组,所以与其他容器相比,vector 能非常方便和高效访问单个元素
  1. 向量是动态结构,它的大小不固定,可以在程序运行时增加或减少
    与数组不同,向量的内存用尽时,向量自动分配更大的连续内存区,将原先的元素复制到新的内存区,并释放旧的内存区;因此得称——无限数组

vector 基本操作

1.头文件
#include<vector>

2.创建一个vector
vector<int> vec;

3.尾部插入数字
vec.push_back(a);

4.使用下标访问元素
cout<<vec[0]<<endl;记住下标是从0开始的

5.使用迭代器访问元素
vector<int>::iterator it;
for(it=vec.begin();it!=vec.end();it++)
cout<<*it<<endl;

6.插入元素
vec.insert(vec.begin()+i,a);在第i+1个元素前面插入a;

7.删除元素   
vec.erase(vec.begin()+2);删除第3个元素
vec.erase(vec.begin()+i,vec.end()+j);删除区间[i,j-1];区间从0开始

8.向量大小
vec.size();
vec.resize;改变大小

9.清空
vec.clear();

stack

  1. 栈遵循后进先出的原则,即最后一个被添加到栈中的元素总是第一个被移除。
  1. 栈是一种线性数据结构。栈只允许在一端(称为栈顶)进行插入和删除操作。栈中没有元素时,称为空栈。

stack 基本操作

1.头文件
#include<stack>

2.创建栈
stack<int> s;

3.压栈
s.push(a);

4.访问栈顶元素
int a=s.top();

5.弹出栈顶元素
s.pop();

6.获取栈中元素数量
int a=s.size();

7.检测栈是否为空
s.empty() 为空返回True

queue

  1. 队列是一个常用的容器适配器。它提供了一种先进先出的数据结构,类似于现实生活中的排队。
  1. 双端队列是一个双向开口的连续线性空间,可以在两端进行高效的插入和删除操作。

queue 基本操作

1.头文件
#include<queue>

2.创建队列
queue<int> q;

3.队尾插入元素
q.push(a);

4.访问队首元素
int a=q.front();

5.删除队首元素
q.pop();

6.查询队列是否为空
q.empty(); 为空返回True

deque 基本操作

1.头文件
#include<deque>

2.创建双端队列
deque<int> dq;

3.插入元素
队尾 dq.push_back(a);
队首 dq.push_front(a);

4.访问元素
队首 int a=dq.front();
队尾 int a=dq.back();

5.删除元素
队首 dq.pop_front();
队尾 dq.pop_back();
队中 dq.erase(iterator it);
队中区间 dq.erase(iterator first,iterator last);

6.判断是否为空
dq.empty(); 为空返回True

7.获取元素数量
int a=dq.size();

8.清空
dq.clear();

map

  1. 增加和删除节点对迭代器的影响很小。对于迭代器来说,可以修改实值,而不能修改key
  1. 自动建立key - value的对应。key 和 value可以是任意你需要的类型
  1. 根据key值快速查找记录,查找的复杂度基本是O( \log N),如果有1000个记录,最多查找10次,1,000,000个记录,最多查找20次

map 基本操作

1.头文件
#include<map>

2.创建map
map<string,int> mp;

3.插入元素
string a,int b;
mp[a]=b;

4.获取元素
int c=mp[a];必须事先存储过这个值

set

  1. set 属于关联容器的一种。它是一个有序集合,其中的元素是唯一的,即每个元素只能在集合中出现一次。
  1. set 是基于红黑树实现的,这使得插入、删除和查找操作的时间复杂度都是 O( \log n)。

set 基本操作

1.头文件
#include<set>

2.创建set
set<int> t;

3.插入元素
t.insert(a);

4.删除元素
根据值删除 t.erase(a);
根据迭代器删除 t.erase(iterator it);

5.查找元素
t.find(a);

6.查询是否为空
t.empty();为空返回True

7.清空
t.clear();

8.查询元素个数
int a=t.size();

list

  1. list是可以在常数范围内任意位置进行插入和删除的序列式容器,并且该容器可以前后双向迭代。
  1. list的底层是双向链表结构,双向链表中每个元素存储在互不相关的独立节点中,在节点中通过指针指向其前一个元素和后一个元素。
  1. 与其他的序列式容器相比, list通常在任意位置进行插入,移除元素的执行效率更好。
  1. 与其他序列式容器相比,list和forward_list的最大缺陷是不支持任意位置的随机访问。这跟链表的随机访问是一致的,效率极低。

list 基本操作

1.头文件
#include<list>

2.创建list
list<int> l;

3.表头插入元素
l.push_front(a);

4.删除元素
l.remove(a);

5.访问元素
头 int a=l.begin();
尾 int a=l.end();

迭代器

迭代器是一种检查容器内元素并遍历元素的数据类型。
你可以通过以下操作使用迭代器

vector<int> vec;//定义一个vector
...
vector<int>::iterator it;//定义一个vector类型的迭代器
for(it=vec.begin();it<=vec.end();it++){
    cout<<*it<<endl;//输出
}

当然,新版c++有个NB的东西
auto!
所以你可以这样创造一个迭代器

vector<int> vec;//定义vector
...
for(auto it:vec){//定义迭代器
    cout<<*it<<endl;//输出
}

这就是这篇帖子的所有内容了
拜拜ヾ(•ω•`)o
制作不易,求点赞

8 个赞

膜拜大佬(有用,收了)

orz,大佬,orz

@王语道 虽然水,但好歹也写了,不过我推荐OI-Wiki