各类容器基本概念介绍

最新推荐文章于 2024-05-28 06:15:00 发布

原创最新推荐文章于 2024-05-28 06:15:00 发布 · 438 阅读

2 ·

CC 4.0 BY-SA版权

文章标签：

#链表 #数据结构 #c++ #容器

STL 专栏收录该内容

9 篇文章

订阅专栏

本文详细介绍了C++STL中的各种容器，包括序列式容器如string、vector、deque、stack、queue、list，以及关联式容器如set、map。涵盖了它们的构造函数、赋值操作、容量大小管理、插入删除元素、数据存取以及交换排序等基本操作。同时，解释了栈和队列的原则，以及set和map的自动排序特性。

序列式容器：

Array：固定大小，初始多少就是多少

Vector：单端数组，容器不够会自动增长，内存的分配器做这个事情，动态扩展并不是在原空间之后续接新空间，而是找更大的内存空间，然后将原数据拷贝新空间，释放原空间

Deque：双端数组，两头都可以添加，本质是由中控器和缓冲区组成，中控器记录缓冲区地址，缓冲区中存放真实的数据，使得看起来是一片连续的内存空间

List：双向链表、单向链表

stack容器：stack容器是栈，原则：先进后出，栈中只有顶端的元素可以被外界使用，因此不允许有遍历的行为

queue容器：queue容器是队列，原则：先进先出，队列容器允许从一端新增元素，从另一端移除元素。队列中只有队头和队尾才可以被外界使用，因此队列不允许有遍历行为

关联式容器：

底层由红黑树：高度平衡二叉树

set容器中的所有元素都会在插入时被自动排序，它属于关联式容器，底层结构是用二叉树实现。set和multiset区别：1、set不允许容器中有重复的元素 2、multiset允许容器中有重复的元素

map容器中所有元素都是pair，pair中第一个元素为key（键值），起到索引作用，第二个元素为value（实值），所有元素都会根据元素的键值自动排序。它也属于关联式容器，底层结构是用二叉树实现。可以根据key值快速找到value值。map和multimap区别：1、map不允许容器中有重复key值元素 2、multimap允许容器中有重复key值元素

set key和val是一个值，map key和val不同，set的元素不能重复，map的key不能重复。Multimap表示可重复。

Unordered Set：不定序

哈希碰撞： 拉链法

1、构造函数

1.1 string容器

string(); //创建一个空的字符串例如: string str;
string(const char* s); //使用字符串s初始化
string(const string& str); //使用一个string对象初始化另一个string对象
string(int n, char c); //使用n个字符c初始化

1.2 vector容器

vector<T> v; //采用模板实现类实现，默认构造函数
vector(v.begin(), v.end()); //将v[begin(), end())区间中的元素拷贝给本身。
vector(n, elem); //构造函数将n个elem拷贝给本身。
vector(const vector &vec); //拷贝构造函数。

1.3 deque容器

deque<T> deqT; //默认构造形式
deque(beg, end); //构造函数将[beg, end)区间中的元素拷贝给本身。
deque(n, elem); //构造函数将n个elem拷贝给本身。
deque(const deque &deq); //拷贝构造函数

1.4 stack容器（栈）

stack<T> stk; //stack采用模板类实现， stack对象的默认构造形式
stack(const stack &stk); //拷贝构造函数

1.5 queue容器（队列）

queue<T> que; //queue采用模板类实现，queue对象的默认构造形式
queue(const queue &que); //拷贝构造函数

1.6 list容器（链表）

list<T> lst; //list采用采用模板类实现,对象的默认构造形式：
list(beg,end); //构造函数将[beg, end)区间中的元素拷贝给本身。
list(n,elem); //构造函数将n个elem拷贝给本身。
list(const list &lst); //拷贝构造函数。

1.7 set容器（自动排序）

multiset允许容器有重复的元素

set<T> st; //默认构造函数：
set(const set &st); //拷贝构造函数

1.8 map容器（自动排序）

所有元素都是pair，first元素为key，second元素为value

multimap允许容器有重复的key值

map<T1, T2> mp; //map默认构造函数:
map(const map &mp); //拷贝构造函数

2、赋值操作

2.1 string容器

string& operator=(const char* s); //char*类型字符串赋值给当前的字符串
string& operator=(const string &s); //把字符串s赋给当前的字符串
string& operator=(char c); //字符赋值给当前的字符串
string& assign(const char *s); //把字符串s赋给当前的字符串
string& assign(const char *s, int n); //把字符串s的前n个字符赋给当前的字符串
string& assign(const string &s); //把字符串s赋给当前字符串
string& assign(int n, char c); //用n个字符c赋给当前字符串

2.2 vector容器

vector& operator=(const vector &vec);//重载等号操作符
assign(beg, end); //将[beg, end)区间中的数据拷贝赋值给本身。
assign(n, elem); //将n个elem拷贝赋值给本身。

2.3 deque容器

deque& operator=(const deque &deq); //重载等号操作符
assign(beg, end); //将[beg, end)区间中的数据拷贝赋值给本身
assign(n, elem); //将n个elem拷贝赋值给本身。

2.4 stack容器（栈）

stack& operator=(const stack &stk); //重载等号操作符

2.5 queue容器（队列）

queue& operator=(const queue &que); //重载等号操作符

2.6 list容器（链表）

assign(beg, end); //将[beg, end)区间中的数据拷贝赋值给本身。
assign(n, elem); //将n个elem拷贝赋值给本身。
list& operator=(const list &lst); //重载等号操作符

2.7 set容器（自动排序）

multiset允许容器有重复的元素

set& operator=(const set &st); //重载等号操作符

2.8 map容器（自动排序）

所有元素都是pair，first元素为key，second元素为value

multimap允许容器有重复的key值

map& operator=(const map &mp); //重载等号操作符

3、容量和大小操作

3.1 string容器

3.2 vector容器

empty(); //判断容器是否为空
capacity(); //容器的容量

[容量] 与deque和list容器不同，这是vector独有的
size(); //返回容器中元素的个数
resize(int num); //重新指定容器的长度为num，若容器变长，则以默认值填充新位置。

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

//如果容器变短，则末尾超出容器长度的元素被删除

3.3 deque容器

deque.empty(); //判断容器是否为空
deque.size(); //返回容器中元素的个数
deque.resize(num); //重新指定容器的长度为num,若容器变长，则以默认值填充新位置。

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

//如果容器变短，则末尾超出容器长度的元素被删除。

3.4 stack容器（栈）

empty(); //判断堆栈是否为空
size(); //返回栈的大小

3.5 queue容器（队列）

empty(); //判断堆栈是否为空
size(); //返回栈的大小

3.6 list容器（链表）

size(); //返回容器中元素的个数
empty(); //判断容器是否为空
resize(num); //重新指定容器的长度为num，若容器变长，则以默认值填充新位置。

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

//如果容器变短，则末尾超出容器长度的元素被删除。

3.7 set容器（自动排序）

multiset允许容器有重复的元素

size(); //返回容器中元素的数目
empty(); //判断容器是否为空

3.8 map容器（自动排序）

所有元素都是pair，first元素为key，second元素为value

multimap允许容器有重复的key值

size(); //返回容器中元素的数目
empty(); //判断容器是否为空

4、插入和删除操作

4.1 string容器

string& insert(int pos, const char* s); //插入字符串
string& insert(int pos, const string& str); //插入字符串
string& insert(int pos, int n, char c); //在指定位置插入n个字符c
string& erase(int pos, int n = npos); //删除从Pos开始的n个字符

[容器] 从下方开始，括号内输入的是：迭代器

4.2 vector容器

push_back(ele); //尾部插入元素ele
pop_back(); //删除最后一个元素
insert(const_iterator pos, ele); //迭代器指向位置pos插入元素ele
insert(const_iterator pos, int count,ele);//迭代器指向位置pos插入count个元素ele
erase(const_iterator pos); //删除迭代器指向的元素
erase(const_iterator start, const_iterator end);//删除迭代器从start到end之间的元素
clear();

4.3 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位置的数据，返回下一个数据的位置。

4.4 stack容器（栈）

push(elem); //向栈顶添加元素

4.5 queue容器（队列）

push(elem); //往队尾添加元素

4.6 list容器（链表）

push_back(elem);//在容器尾部加入一个元素
pop_back();//删除容器中最后一个元素
push_front(elem);//在容器开头插入一个元素
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位置的数据，返回下一个数据的位置。
remove(elem);//删除容器中所有与elem值匹配的元素。

[remove] 这是与deque容器不同的地方

4.7 set容器（自动排序）

multiset允许容器有重复的元素

insert(elem); //在容器中插入元素。
clear(); //清除所有元素
erase(pos); //删除pos迭代器所指的元素，返回下一个元素的迭代器。
erase(beg, end); //删除区间[beg,end)的所有元素，返回下一个元素的迭代器。
erase(elem); //删除容器中值为elem的元素。

4.8 map容器（自动排序）

所有元素都是pair，first元素为key，second元素为value

multimap允许容器有重复的key值

insert(elem); //在容器中插入元素。
clear(); //清除所有元素
erase(pos); //删除pos迭代器所指的元素，返回下一个元素的迭代器。
erase(beg, end); //删除区间[beg,end)的所有元素，返回下一个元素的迭代器。
erase(key); //删除容器中值为key的元素。

[注意] set与map容器删除指定元素的不同：set是删除值为elem的元素，而map是删除key为elem的元素

四种插入方式：

map<int, int> m;
    //第一种插入方式
    m.insert(pair<int, int>(1, 10));
    
    //第二种插入方式(***)
    m.insert(make_pair(2,20));

    //第三种插入方式(太长，不建议使用)
    m.insert(map<int, int>::value_type(3, 30));

    //第四种插入方式(不建议使用)
    m[4] = 40;
    //cout << m[5] << endl;         //使用第四种方式，使得有 m[5]=0 ，但实际并不需要

5、数据存取

5.1 string容器

char& operator[](int n); //通过[]方式取字符
char& at(int n); //通过at方法获取字符

5.2 vector容器

at(int idx); //返回索引idx所指的数据
operator[]; //返回索引idx所指的数据
front(); //返回容器中第一个数据元素
back(); //返回容器中最后一个数据元素

5.3 deque容器

at(int idx); //返回索引idx所指的数据
operator[]; //返回索引idx所指的数据
front(); //返回容器中第一个数据元素
back(); //返回容器中最后一个数据元素

5.4 stack容器（栈）

push(elem); //向栈顶添加元素
pop(); //从栈顶移除第一个元素
top(); //返回栈顶元素

5.5 queue容器（队列）

push(elem); //往队尾添加元素
pop(); //从队头移除第一个元素
back(); //返回最后一个元素
front(); //返回第一个元素

5.6 list容器（链表）

front(); //返回第一个元素。
back(); //返回最后一个元素。

5.7 set容器（自动排序）

multiset允许容器有重复的元素

5.8 map容器（自动排序）

所有元素都是pair，first元素为key，second元素为value

multimap允许容器有重复的key值

6、交换和排序

6.1 string容器

6.2 vector容器

swap(vec); // 将vec与本身的元素互换

6.3 deque容器

sort(iterator beg, iterator end) //对beg和end区间内元素进行排序

6.4 stack容器（栈）

6.5 queue容器（队列）

6.6 list容器（链表）

reverse(); //反转链表
sort(); //链表排序

6.7 set容器（自动排序）

multiset允许容器有重复的元素

swap(st); //交换两个集合容器
利用仿函数，可以改变排序规则
默认升序；降序：在class类函数内定义仿函数，并导入set初始化类型中

6.8 map容器（自动排序）

所有元素都是pair，first元素为key，second元素为value

multimap允许容器有重复的key值

swap(st); //交换两个集合容器

利用仿函数，可以改变排序规则
默认升序；降序：在class类函数内定义仿函数，并导入map初始化类型中

7、其余操作

7.1 string容器

字符串拼接

string& operator+=(const char* str); //重载+=操作符
string& operator+=(const char c); //重载+=操作符
string& operator+=(const string& str); //重载+=操作符
string& append(const char *s); //把字符串s连接到当前字符串结尾
string& append(const char *s, int n); //把字符串s的前n个字符连接到当前字符串结尾
string& append(const string &s); //同operator+=(const string& str)
string& append(const string &s, int pos, int n);//字符串s中从pos开始的n个字符连接到字符串结尾

查找和替换

int find(const char* s, int pos = 0) const; //查找s第一次出现位置,从pos开始查找
int find(const char* s, int pos, int n) const; //从pos位置查找s的前n个字符第一次位置
int find(const char c, int pos = 0) const; //查找字符c第一次出现位置
int rfind(const string& str, int pos = npos) const; //查找str最后一次位置,从pos开始查找
int rfind(const char* s, int pos = npos) const; //查找s最后一次出现位置,从pos开始查找
int rfind(const char* s, int pos, int n) const; //从pos查找s的前n个字符最后一次位置
int rfind(const char c, int pos = 0) const; //查找字符c最后一次出现位置
string& replace(int pos, int n, const string& str); //替换从pos开始n个字符为字符串str
string& replace(int pos, int n,const char* s); //替换从pos开始的n个字符为字符串s