文章目录
三、常用容器
1、string容器
1.1、string容器基本概念
C风格字符串（以空字符结尾的字符数组）太过复杂难于掌握，不适合大程序的开发，所以C++标准库定义了一种string类。
C++的字符串与C语言的字符串比较
- C语言:
char*是一个指针。 - C++:
string是一个类，内部封装了char*，用来管理这个容器。string类中封装了很多的功能函数，非常实用。例如：find、copy、delete、replace、insert等。- 不用考虑内存释放和越界的问题。
string管理char*所分配的内存。每一次string的复制，取值都由string类负责维护，不用担心复制越界和取值越界等。
1.2、string容器常用操作
-
string构造函数
string(); //创建一个空的字符串 例如：string str; string(const string& str); //使用一个string对象初始化另一个string对象 string(const char* s); //使用字符串s初始化 string(int n, char c); //使用n个字符c初始化 -
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赋给当前字符串 string& assign(const string &s, int start, int n); // 将s从start开始n个字符赋值给字符串 -
string存取字符操作
char& operator[](int n); //通过[]方式取字符 char& at(int n); //通过at方法获取字符 -
string拼接操作
string& operator+=(const string& str); //重载+=操作符 string& operator+=(const char* str); //重载+=操作符 string& operator+=(const char c); //重载+=操作符 string& append(const char *s); //把字符串s连接到当前字符串结尾 string& append(const char *s, int n); //把字符串s的前n个字符连接到当前字符串结尾 string& append(const string &s); //同operator+=() string& append(const string &s, int pos, int n); //把字符串s中从pos开始的n个字符连接到当前字符串结尾 string& append(int n, char c); //在当前字符串结尾添加n个字符c -
string查找和替换
int find(const string& str, int pos = 0) const; //查找str第一次出现位置，从pos开始查找 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 -
string比较操作
/* compare函数在>时返回 1，<时返回 -1，==时返回 0。 比较区分大小写，比较时参考字典顺序，排越前面的越小。 大写的A比小写的a小。 */ int compare(const string &s) const; //与字符串s比较 int compare(const char *s) const; //与字符串s比较 -
string子串
string substr(int pos = 0, int n = npos) const; //返回由pos开始的n个字符组成的字符串 -
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个字符 -
string和C语言风格字符串转换
//string 转 char* string str = "itcast"; const char* cstr = str.c_str(); //char* 转 string char* s = "itcast"; string str(s);在C++中存在一个从const char到string的隐式类型转换，却不存在从一个string对象到Cstring的自动类型转换。 对于string类型的字符串，可以通过cstr（）函数返回string对象对应的C_string. 通常，程序员在整个程序中应坚持使用string类对象，直到必须将内容转换为char时才将其转换为C_string.
提示：
为了修改string字符串的内容，下标操作符[]和at都会返回字符的引用。但当字符串的内存被重新分配之后，可能发生错误。
string s = "abcdefg";
char& a = s[2];
char& b = s[3];
a = '1';
b = '2';
cout << s << endl;
cout << (int*)s.c_str() << endl;
s = "pppppppppppppppppppppppp";
//a = '1';
//b = '2';
cout << s << endl;
cout << (int*)s.c_str() << endl;
2、vector容器
2.1、vector容器基本概念
vector的数据安排以及操作方式，与array非常相似，两者的唯一差别在于空间的运用的灵活性。Array是静态空间，一旦配置了就不能改变，要换大一点或者小一点的空间，可以，一切琐碎得由自己来，首先配置一块新的空间，然后将旧空间的数据搬往新空间，再释放原来的空间。Vector是动态空间，随着元素的加入，它的内部机制会自动扩充空间以容纳新元素。因此vector的运用对于内存的合理利用与运用的灵活性有很大的帮助，我们再也不必害怕空间不足而一开始就要求一个大块头的array了。
2.2、vector容器常用操作
-
vector的构造函数
vector<T> v; //采用模板实现类实现，默认构造函数 vector(v.begin(), v.end()); //将v[begin(), end()]区间中的元素拷贝给本身。 vector(n, elem); //构造函数将n个elem拷贝给本身。 vector(const vector &vec); //拷贝构造函数。 //例子 使用第二个构造函数 我们可以... int arr[] = {2, 3, 4, 1, 9}; vector<int> v1(arr, arr + sizeof(arr) / sizeof(int)); -
vector的常用赋值函数
assign(beg, end); //将[beg, end)区间中的数据拷贝赋值给本身。 assign(n, elem); //将n个elem拷贝赋值给本身。 vector& operator=(const vector &vec); //重载等号操作符 swap(vec); //将vec与本身的元素互换。 -
vector的大小操作
size(); //返回容器中元素的个数 empty(); //判断容器是否为空 resize(int num); //重新指定容器的长度为num，若容器变长，则以默认值填充新位置。如果容器变短，则末尾超出容器长度的元素被删除。 resize(int num, elem); //重新指定容器的长度为num，若容器变长，则以elem值填充新位置。如果容器变短，则末尾超出容器长度的元素被删除。 capacity(); //容器的容量 reserve(int len); //容器预留len个元素长度，预留位置不初始化，元素不可访问。 -
vector的数据存取操作
at(int idx); //返回索引idx所指的数据，如果idx越界，抛出out_of_range异常。 operator[]; //返回索引idx所指的数据，越界时，运行直接报错 front(); //返回容器中第一个数据元素 back(); //返回容器中最后一个数据元素 -
vector插入和删除操作
insert(const_iterator pos, int count, ele); //迭代器指向位置pos插入count个元素ele。 push_back(ele); //尾部插入元素ele pop_back(); //删除最后一个元素 erase(const_iterator start, const_iterator end); //删除迭代器从start到end之间的元素 erase(const_iterator pos); //删除迭代器指向的元素 clear(); //删除容器中所有元素
2.3、vector迭代器
Vector维护一个线性空间，所以不论元素的型别如何，普通指针都可以作为vector的迭代器，因为vector迭代器所需要的操作行为，如operator, operator->, operator++, operator–, operator+, operator-, operator+=, operator-=，普通指针天生具备。Vector支持随机存取，而普通指针正有着这样的能力。所以vector提供的是随机访问迭代器(Random Access Iterators).
// vector提供了begin()函数，用来返回指向首元素的指针
// vector提供了end()函数，用来返回指向最后一位元素的下一位的指针
// 创建容器
vector<int> v;
// 向容器中添加元素
v.push_back(1);
v.push_back(3);
v.push_back(5);
v.push_back(7);
v.push_back(9);
// 使用迭代器遍历容器
for (vector<int>::iterator it = v.begin(); it != v.end(); it++) {
cout << *it << endl;
}
// 使用迭代器倒序遍历容器
for (vector<int>::iterator it = v.end(); it != v.begin(); ) {
it--;
cout << *it << endl;
}
// 迭代器遍历容器，可以缩写为for循环的写法
for (int& it : v) {
cout << it << endl;
}
// 在使用迭代器遍历容器的过程中，可以通过指针或者是引用来修改到容器中的值
2.4、vector小案例
-
巧用swap收缩内存空间
#include<iostream> #include<vector> using namespace std; int main(){ vector<int> v; for (int i = 0; i < 100000; i++){ v.push_back(i); } cout << "capacity:" << v.capacity() << endl; cout << "size:" << v.size() << endl; // 此时 通过resize改变容器大小 v.resize(10); cout << "capacity:" << v.capacity() << endl; cout << "size:" << v.size() << endl; //容量没有改变 vector<int>(v).swap(v); cout << "capacity:" <<v.capacity() << endl; cout << "size:" << v.size() << endl; system("pause"); return EXIT_SUCCESS; -
reserve预留空间
#include<iostream> #include<vector> using namespace std; int main(){ vector<int> v; // 预先开辟空间 v.reserve(100000); int* pStart = NULL; int count = 0; for (int i = 0; i < 100000; i++){ v.push_back(i); if (pStart != &v[0]){ pStart = &v[0]; count++; } } cout << "count:" << count << endl; system("pause"); return EXIT_SUCCESS; }
3、deque容器
3.1、deque容器基本概念
Vector容器是单向开口的连续内存空间，deque则是一种双向开口的连续线性空间。所谓的双向开口，意思是可以头尾两端分别做元素的插入和删除操作，当然，vector容器也可以在头尾两端插入元素，但是在其头部操作效率奇差，无法被接受。
deque容器和vector容器最大的差异，一在于deque允许对头端进行元素的插入和删除操作。二在于deque没有容量的概念，因为它是动态的以分段连续空间组合而成，随时可以增加一段新的空间并链接起来，换句话说，像vector那样，“旧空间不足而重新配置一块更大空间，然后复制元素，再释放旧空间”这样的事情在deque身上是不会发生的。也因此，deque没有必须要提供所谓的空间保留(reserve)功能。
虽然deque容器也提供了Random Access Iterator，但是它的迭代器并不是普通的指针，其复杂度和vector不是一个量级，这当然影响各个运算的层面。因此，除非有必要，我们应该尽可能的使用vector，而不是deque。对deque进行的排序操作，为了最高效率，可将deque先完整的复制到一个vector中，对vector容器进行排序，再复制回deque。
3.2、deque容器常用操作
-
deque构造函数
deque<T> deqT; //默认构造形式 deque(beg, end); //构造函数将[beg, end)区间中的元素拷贝给本身。 deque(n, elem); //构造函数将n个elem拷贝给本身。 deque(const deque &deq); //拷贝构造函数。 -
deque赋值操作
assign(beg, end); //将[beg, end)区间中的数据拷贝赋值给本身。 assign(n, elem); //将n个elem拷贝赋值给本身。 deque& operator=(const deque &deq); //重载等号操作符 swap(deq); //将deq与本身的元素互换 -
deque大小操作
deque.size(); //返回容器中元素的个数 deque.empty(); //判断容器是否为空 deque.resize(num); //重新指定容器的长度为num，若容器变长，则以默认值填充新位置。如果容器变短，则末尾超出容器长度的元素被删除。 deque.resize(num, elem); //重新指定容器的长度为num，若容器变长，则以elem值填充新位置。如果容器变短，则末尾超出容器长度的元素被删除。 -
deque双端操作和删除
push_back(elem); //在容器尾部添加一个数据 push_front(elem); //在容器头部插入一个数据 pop_back(); //删除容器最后一个数据 pop_front(); //删除容器第一个数据 -
deque数据存取
at(idx); //返回索引idx所指的数据，如果idx越界，抛出out_of_range。 operator[]; //返回索引idx所指的数据，如果idx越界，不抛出异常，直接出错。 front(); //返回第一个数据 back(); //返回最后一个数据 -
deque插入操作
insert(pos, elem); //在pos位置插入一个elem元素的拷贝，返回新数据的位置。 insert(pos, n, elem); //在pos位置插入n个elem数据，无返回值。 insert(pos, beg, end); //在pos位置插入[beg, end)区间的数据，无返回值。 -
deque删除操作
clear(); //移除容器的所有数据 erase(beg, end); //删除[beg, end)区间的数据，返回下一个数据的位置。 erase(pos); //删除pos位置的数据，返回下一个数据的位置。
3.3、deque小案例
有5名选手：选手ABCDE，10个评委分别对每一名选手打分，去除最高分，去除评委中最低分，取平均分。
- 创建五名选手，放到vector中
- 遍历vector容器，取出来每一个选手，执行for循环，可以把10个评分打分存到deque容器中
- sort算法对deque容器中分数排序，pop_back pop_front去除最高和最低分
- deque容器遍历一遍，累加分数，累加分数/d.size()
- person.score = 平均分
#include <iostream>
#include <vector>
#include <deque>
#include <algorithm>
#include <cstdlib>
#include <ctime>
using namespace std;
// 定义选手结构体
struct Person {
string name;
double score = 0.0;
};
int main() {
// 初始化随机数种子
srand(static_cast<unsigned>(time(nullptr)));
// 创建选手
vector<Person> persons = {
{"A"}, {"B"}, {"C"}, {"D"}, {"E"}
};
// 遍历选手
for (auto& person : persons) {
// 随机生成10个评委的评分，范围为1-100
deque<int> scores;
for (int i = 0; i < 10; ++i) {
scores.push_back(rand() % 100 + 1);
}
// 打印原始评分
cout << "选手 " << person.name << " 的评分：";
for (int score : scores) {
cout << score << " ";
}
cout << endl;
// 对评分排序
sort(scores.begin(), scores.end());
// 去掉最高分和最低分
scores.pop_back();
scores.pop_front();
// 计算平均分
int total = 0;
for (int score : scores) {
total += score;
}
person.score = static_cast<double>(total) / scores.size();
}
// 输出选手得分
for (const auto& person : persons) {
cout << "选手 " << person.name << " 的平均得分为：" << person.score << endl;
}
return 0;
}
vector容器和deque容器的区别
vector 和 deque 都是 C++ 标准库中的顺序容器（sequence containers），用于存储和管理元素，但它们的内部实现和使用场景有显著区别。
1. 概述
vector：是一个动态数组，其元素在内存中是连续存储的，支持快速的随机访问。deque：是双端队列，内部实现通常是分段的数组（分块存储），支持双端快速插入和删除。
2. 内存存储结构
-
vector：- 内存是连续的，类似于数组。
- 当元素数量超出容量时，需要重新分配更大的内存，并将原有元素复制到新的内存区域（重分配开销较大）。
-
deque：- 内部采用分段存储，每段内存是连续的，但不同段之间不连续。
- 由一个索引数组指向各个分段。
- 分段存储使得
deque在头部和尾部都可以快速插入和删除元素。
3. 随机访问性能
-
vector：- 由于元素连续存储，
vector支持常数时间的随机访问（通过索引直接访问）。 - 例如：
vec[i]的时间复杂度为 O(1)。
- 由于元素连续存储，
-
deque：- 虽然
deque也支持随机访问，但因为分段存储，需要先通过索引数组定位到具体分段，再定位到分段内的元素。 - 因此
deque的随机访问比vector慢，时间复杂度仍是 O(1)，但有额外的开销。
- 虽然
4. 插入和删除性能
-
vector：- 尾部插入：时间复杂度为 O(1)（在没有重分配的情况下）。
- 头部插入：时间复杂度为 O(n)，因为需要移动所有元素。
- 中间插入或删除：时间复杂度为 O(n)，需要移动后续的元素。
-
deque：- 头部和尾部插入/删除：时间复杂度为 O(1)。
- 中间插入或删除：时间复杂度为 O(n)，因为需要移动分段内的元素。
5. 迭代器有效性
-
vector：- 当进行插入或删除操作导致重分配内存时，所有的迭代器和引用都会失效。
- 在不重分配的情况下，尾部操作不会影响迭代器。
-
deque：- 由于分段存储，头部或尾部插入/删除不会使全部迭代器失效，但仍有部分迭代器会失效。
- 中间插入或删除会使部分迭代器失效。
6. 适用场景
-
vector：- 适用于需要频繁随机访问元素，且尾部插入操作较多的场景。
- 例如：存储大量数据、需要快速索引的场景。
-
deque：- 适用于需要频繁在头部和尾部插入/删除元素的场景，且对随机访问要求不那么高。
- 例如：实现队列（如双端队列）、数据流处理等。
7. 常用操作对比
| 操作 | vector 性能 | deque 性能 |
|---|---|---|
| 随机访问 | O(1)，非常快 | O(1)，较快但稍慢 |
| 尾部插入/删除 | O(1)，但可能重分配 | O(1) |
| 头部插入/删除 | O(n) | O(1) |
| 中间插入/删除 | O(n) | O(n) |
| 内存存储 | 连续存储 | 分段存储 |
8. 示例代码
#include <iostream>
#include <vector>
#include <deque>
using namespace std;
int main() {
// vector 示例
vector<int> vec;
vec.push_back(1); // 尾部插入
vec.push_back(2);
vec.push_back(3);
cout << "Vector 内容: ";
for (int val : vec) cout << val << " ";
cout << endl;
// deque 示例
deque<int> dq;
dq.push_front(1); // 头部插入
dq.push_back(2); // 尾部插入
dq.push_back(3);
cout << "Deque 内容: ";
for (int val : dq) cout << val << " ";
cout << endl;
return 0;
}
输出结果：
Vector 内容: 1 2 3
Deque 内容: 1 2 3
总结
-
选择
vector：- 需要快速随机访问，主要在尾部插入元素。
- 内存连续存储，性能高，但重分配开销较大。
-
选择
deque：- 需要快速头部和尾部插入/删除操作。
- 分段存储使得它更适用于双端操作，但随机访问性能略低。
根据具体需求合理选择容器，vector 和 deque 各有所长。
4、stack容器
4.1、stack容器基本概念
stack是一种先进后出(First In Last Out, FILO)的数据结构，它只有一个出口，形式如图所示。stack容器允许新增元素，移除元素，取得栈顶元素，但是除了最顶端外，没有任何其他方法可以存取stack的其他元素。换言之，stack不允许有遍历行为。
有元素推入栈的操作称为push，将元素推出stack的操作称为pop。
stack是没有迭代器的：
Stack所有元素的进出都必须符合“先进后出”的条件，只有stack顶端的元素，才有机会被外界取用。Stack不提供遍历功能，也不提供迭代器。
4.2、stack容器常用操作
-
构造函数
stack<T> stkT; // stack采用模板类实现，stack对象的默认构造形式: stack(const stack &stk); // 拷贝构造函数 -
赋值操作
stack& operator=(const stack &stk); // 重载等号操作符 -
数据存取操作
push(elem); // 向栈顶添加元素 pop(); // 从栈顶移除第一个元素 top(); // 返回栈顶元素 -
大小操作
empty(); // 判断堆栈是否为空 size(); // 返回堆栈的大小
5、queue容器
5.1、queue容器基本概念
Queue是一种先进先出(First In First Out, FIFO)的数据结构，它有两个出口，queue容器允许从一端新增元素，从另一端移除元素。
5.2、queue容器常用操作
-
构造函数
queue<T> queT; // queue采用模板类实现，queue对象的默认构造形式: queue(const queue &que); // 拷贝构造函数 -
存取、插入、删除操作
push(elem); // 往队尾添加元素 pop(); // 从队头移除第一个元素 back(); // 返回最后一个元素 front(); // 返回第一个元素 -
赋值操作
queue& operator=(const queue &que); // 重载等号操作符 -
大小操作
empty(); // 判断队列是否为空 size(); // 返回队列的大小
vector容器和deque容器的区别
stack 和 queue 是 C++ 标准库中提供的容器适配器，它们是基于顺序容器（如 vector、deque）实现的，主要区别在于数据的存取方式和应用场景不同。
1. 概述
-
stack：栈是一种后进先出（LIFO, Last In First Out） 的数据结构。- 只允许在栈顶进行插入和删除操作。
- 适用于需要逆序处理的场景，如括号匹配、递归模拟等。
-
queue：队列是一种先进先出（FIFO, First In First Out） 的数据结构。- 元素从队列的尾部插入，从头部删除。
- 适用于需要顺序处理的场景，如任务调度、数据流处理等。
2. 内部实现
stack和queue并不是独立的容器，它们是容器适配器，底层可以基于不同的容器实现，默认使用deque容器。- 可使用的底层容器包括：
deque、list和vector（queue不支持vector）。
3. 操作方式对比
| 操作 | stack | queue |
|---|---|---|
| 插入 | push() - 入栈 | push() - 入队（尾部） |
| 删除 | pop() - 出栈（栈顶） | pop() - 出队（头部） |
| 访问元素 | top() - 访问栈顶元素 | front() - 访问队头元素，back() - 访问队尾元素 |
| 遍历支持 | 不支持遍历 | 不支持遍历 |
| 存取顺序 | 后进先出 (LIFO) | 先进先出 (FIFO) |
4. 使用场景
-
stack：- 适用于逆序处理数据的场景。
- 常用于：
- 函数调用的递归栈。
- 括号匹配问题。
- 深度优先搜索（DFS）。
- 逆序输出数据。
-
queue：- 适用于顺序处理数据的场景。
- 常用于：
- 任务调度。
- 广度优先搜索（BFS）。
- 数据缓冲区（如打印机任务）。
- 流水线处理。
5. 示例代码
stack 示例
#include <iostream>
#include <stack>
using namespace std;
int main() {
stack<int> s;
// 入栈操作
s.push(10);
s.push(20);
s.push(30);
cout << "栈顶元素: " << s.top() << endl;
// 出栈操作
s.pop();
cout << "出栈后栈顶元素: " << s.top() << endl;
return 0;
}
输出结果：
栈顶元素: 30
出栈后栈顶元素: 20
queue 示例
#include <iostream>
#include <queue>
using namespace std;
int main() {
queue<int> q;
// 入队操作
q.push(10);
q.push(20);
q.push(30);
cout << "队头元素: " << q.front() << endl;
cout << "队尾元素: " << q.back() << endl;
// 出队操作
q.pop();
cout << "出队后队头元素: " << q.front() << endl;
return 0;
}
输出结果：
队头元素: 10
队尾元素: 30
出队后队头元素: 20
6. 特性比较总结
| 特性 | stack | queue |
|---|---|---|
| 数据结构 | 栈（LIFO - 后进先出） | 队列（FIFO - 先进先出） |
| 插入位置 | 栈顶 | 队尾 |
| 删除位置 | 栈顶 | 队头 |
| 访问元素 | 仅能访问栈顶元素 (top()) | 访问队头元素 (front()) 和队尾元素 (back()) |
| 遍历 | 不支持直接遍历 | 不支持直接遍历 |
| 适用场景 | 逆序处理、递归、深度优先搜索等 | 顺序处理、广度优先搜索、任务调度等 |
7. 小结
stack用于 后进先出（LIFO）场景，如深度优先搜索、函数调用栈、括号匹配等。queue用于 先进先出（FIFO）场景，如任务调度、数据缓冲区、广度优先搜索等。- 二者都是容器适配器，底层默认使用
deque，也可以使用list替换底层容器。
6、list容器
6.1、list容器基本概念
链表是一种物理存储单元上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。链表由一系列结点（链表中每一个元素称为结点）组成，结点可以在运行时动态生成。每个结点包括两个部分：一个是存储数据元素的数据域，另一个是存储下一个结点地址的指针域。
相较于vector的连续线性空间，list就显得复杂许多，它的好处是每次插入或者删除一个元素，就是配置或者释放一个元素的空间。因此，list对于空间的运用有绝对的精准，一点也不浪费。而且，对于任何位置的元素插入或元素的移除，list永远是常数时间。
List和vector是两个最常被使用的容器。
List容器是一个双向链表。
采用动态存储分配，不会造成内存浪费和溢出
链表执行插入和删除操作十分方便，修改指针即可，不需要移动大量元素
链表灵活，但是空间和时间额外耗费较大
6.2、list的迭代器
List容器不能像vector一样以普通指针作为迭代器，因为其节点不能保证在同一块连续的内存空间上。List迭代器必须有能力指向list的节点，并有能力进行正确的递增、递减、取值、成员存取操作。所谓“list正确的递增，递减、取值、成员取用”是指，递增时指向下一个节点，递减时指向上一个节点，取值时取的是节点的数据值，成员取用时取的是节点的成员。
由于list是一个双向链表，迭代器必须能够具备前移、后移的能力，所以list容器提供的是Bidirectional Iterators。
List有一个重要的性质，插入操作和删除操作都不会造成原有list迭代器的失效。这在vector是不成立的，因为vector的插入操作可能造成记忆体重新配置，导致原有的迭代器全部失效，甚至List元素的删除，也只有被删除的那个元素的迭代器失效，其他迭代器不受任何影响。
6.3、list容器常用操作
-
构造函数
list<T> lstT; // list采用模板类实现，对象的默认构造形式: list(beg, end); // 构造函数将[beg, end)区间中的元素拷贝给本身。 list(n, elem); // 构造函数将n个elem拷贝给本身。 list(const list &lst); // 拷贝构造函数。 -
元素插入和删除操作
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值匹配的元素。 -
大小操作
size(); // 返回容器中元素的个数 empty(); // 判断容器是否为空 resize(num); // 重新指定容器的长度为num， // 若容器变长，则以默认值填充新位置。 // 如果容器变短，则末尾超出容器长度的元素被删除。 resize(num, elem); // 重新指定容器的长度为num， // 若容器变长，则以elem值填充新位置。 // 如果容器变短，则末尾超出容器长度的元素被删除。 -
赋值操作
assign(beg, end); // 将[beg, end)区间中的数据拷贝赋值给本身。 assign(n, elem); // 将n个elem拷贝赋值给本身。 list& operator=(const list &lst); // 重载等号操作符 swap（lst）; // 将lst与本身的元素互换。 -
数据存取操作
front(); // 返回第一个元素。 back(); // 返回最后一个元素 -
反转、排序
reverse(); // 反转链表，比如lst包含1, 3, 5元素，运行此方法后，lst就包含5, 3, 1元素。 sort(); // list排序
7、set和multiset容器
7.1、set和multiset容器基本概念
Set的特性是，所有元素都会根据元素的值自动被排序。Set不允许两个元素有相同的值。
我们可以通过set的迭代器改变set元素的值吗？不行，因为set元素值就是其值，关系到set元素的排序规则。如果任意改变set元素值，会严重破坏set组织。换句话说，set的iterator是一种const_iterator。
set拥有和list某些相同的性质，当对容器中的元素进行插入操作或者删除操作的时候，操作之前所有的迭代器，在操作完成之后依然有效，被删除的那个元素的迭代器必然是一个例外。
multiset特性及用法和set完全相同，唯一的差别在于它允许值重复。set和multiset的底层实现是红黑树，红黑树为平衡二叉树的一种。
树的简单知识：
二叉树就是任何节点最多只允许有两个子节点。分别是左子结点和右子节点
二叉树示意图
二叉搜索树，是指二叉树中的节点按照一定的规则进行排序，使得对二叉树中元素访问更加高效。二叉搜索树的放置规则是：任何节点的元素值一定大于其左子树中的每一个节点的元素值，并且小于其右子树的值。因此从根节点一直向左走，一直到无路可走，即得到最小值；一直向右走，直至无路可走，可得到最大值。那么在二叉搜索树中找到最大元素和最小元素是非常简单的事情。下图为二叉搜索树：
上面我们介绍了二叉搜索树，那么当一个二叉搜索树的左子树和右子树不平衡的时候，那么搜索依据上图表示，搜索9所花费的时间要比搜索17所花费的时间要多，由于我们的输入或者经过我们插入或者删除操作，二叉树失去平衡，造成搜索效率降低。
所以我们有了一个平衡二叉树的概念，所谓的平衡不是指的完全平衡。
二叉搜索树的先序遍历、中序遍历和后序遍历
先序遍历、中序遍历和后序遍历是二叉树遍历的三种深度优先搜索（DFS）方式。
假设树的节点格式为：
A
/ \
B C
/ \ \
D E F
1. 先序遍历 (Preorder Traversal)
- 访问顺序：根节点 → 左子树 → 右子树
- 访问规则：先访问当前节点，然后访问左孩子，最后访问右孩子。
遍历顺序：
A → B → D → E → C → F
2. 中序遍历 (Inorder Traversal)
- 访问顺序：左子树 → 根节点 → 右子树
- 访问规则：先访问左孩子，然后访问当前节点，最后访问右孩子。
遍历顺序：
D → B → E → A → C → F
3. 后序遍历 (Postorder Traversal)
- 访问顺序：左子树 → 右子树 → 根节点
- 访问规则：先访问左孩子，然后访问右孩子，最后访问当前节点。
遍历顺序：
D → E → B → F → C → A
三种遍历顺序总结
| 遍历方式 | 访问顺序 | 示例顺序 |
|---|---|---|
| 先序 | 根 → 左 → 右 | A → B → D → E → C → F |
| 中序 | 左 → 根 → 右 | D → B → E → A → C → F |
| 后序 | 左 → 右 → 根 | D → E → B → F → C → A |
4. 非递归实现（栈实现）
遍历二叉树也可以通过显式栈来实现，这种方法适用于迭代方式：
- 先序遍历：使用栈依次存储未访问的右孩子和左孩子。
- 中序遍历：将所有左孩子依次入栈，逐步访问栈顶节点并向右子树移动。
- 后序遍历：借助两个栈或者一个栈和标志位进行实现。
7.2、set和multiset容器常用操作
-
构造函数
set<T> st; // set默认构造函数: multiset<T> mst; // multiset默认构造函数: set(const set &st); // 拷贝构造函数 -
set赋值
set& operator=(const set &st); // 重载等号操作符 swap(st); // 交换两个集合容器 -
set大小操作
size(); // 返回容器中元素的数目 empty(); // 判断容器是否为空 -
插入和删除操作
insert(elem); // 在容器中插入元素。 clear(); // 清除所有元素 erase(pos); // 删除pos迭代器所指的元素，返回下一个元素的迭代器。 erase(beg, end); // 删除区间[beg, end)的所有元素，返回下一个元素的迭代器。 erase(elem); // 删除容器中值为elem的元素。 -
查找操作
find(key); // 查找键key是否存在，若存在，返回该键的元素的迭代器；若不存在，返回set.end()； count(key); // 查找键key的元素个数 lower_bound(keyElem); // 返回第一个key>=keyElem元素的迭代器。 upper_bound(keyElem); // 返回第一个key>keyElem元素的迭代器。 equal_range(keyElem); // 返回容器中key与keyElem相等的上下限的两个迭代器。
set和multiset容器的区别
set 和 multiset 都是 C++ 标准模板库（STL）中的关联容器，用于存储有序的键（元素），但它们在元素的唯一性和存储规则上存在明显区别。
1. 概述
-
set：- 存储的元素唯一，不允许出现重复值。
- 元素自动按升序（默认）或自定义规则排序。
-
multiset：- 存储的元素允许重复，可以有多个相等的值。
- 元素同样按升序（默认）或自定义规则排序。
2. 内部实现
- 两者的底层实现都是红黑树，即平衡二叉搜索树。
- 区别在于：
set在插入元素时会检查是否存在相同的元素，若存在，则不会插入。multiset在插入元素时不检查重复值，可以插入多个相等的元素。
3. 特性对比
| 特性 | set | multiset |
|---|---|---|
| 元素唯一性 | 元素唯一，不允许重复 | 元素可以重复 |
| 排序 | 默认升序（可自定义比较规则） | 默认升序（可自定义比较规则） |
| 底层结构 | 红黑树 | 红黑树 |
| 插入操作 | 只插入不存在的元素 | 无论元素是否存在，都可以插入 |
| 查找重复元素 | 不适用，因为没有重复元素 | 可以查找所有等于某个值的元素 |
| 时间复杂度 | 插入/删除/查找：O(log n) | 插入/删除/查找：O(log n) |
4. 常用操作对比
| 操作 | set 示例 | multiset 示例 |
|---|---|---|
| 插入元素 | s.insert(10); | ms.insert(10); |
| 删除元素 | s.erase(10); | ms.erase(10); |
| 查找元素 | s.find(10); | ms.find(10); |
| 计数元素个数 | s.count(10); - 结果为0或1 | ms.count(10); - 结果为具体数量 |
| 遍历元素 | 支持迭代器遍历 | 支持迭代器遍历 |
5. 示例代码
set 示例
#include <iostream>
#include <set>
using namespace std;
int main() {
set<int> s;
// 插入元素
s.insert(10);
s.insert(20);
s.insert(10); // 插入重复元素，不会成功
cout << "Set 元素: ";
for (int val : s) {
cout << val << " ";
}
cout << endl;
// 查找元素
if (s.find(10) != s.end()) {
cout << "10 在 set 中存在" << endl;
}
// 删除元素
s.erase(10);
cout << "删除 10 后 Set 元素: ";
for (int val : s) {
cout << val << " ";
}
cout << endl;
return 0;
}
输出结果：
Set 元素: 10 20
10 在 set 中存在
删除 10 后 Set 元素: 20
multiset 示例
#include <iostream>
#include <set>
using namespace std;
int main() {
multiset<int> ms;
// 插入元素
ms.insert(10);
ms.insert(20);
ms.insert(10); // 插入重复元素，允许
cout << "Multiset 元素: ";
for (int val : ms) {
cout << val << " ";
}
cout << endl;
// 查找元素个数
cout << "10 的个数: " << ms.count(10) << endl;
// 删除某个元素（删除所有 10）
ms.erase(10);
cout << "删除 10 后 Multiset 元素: ";
for (int val : ms) {
cout << val << " ";
}
cout << endl;
return 0;
}
输出结果：
Multiset 元素: 10 10 20
10 的个数: 2
删除 10 后 Multiset 元素: 20
6. 关键区别总结
-
元素唯一性：
set不允许重复元素。multiset允许重复元素。
-
插入元素：
set在插入时会检查是否有重复元素，若有，则不插入。multiset直接插入，无论元素是否重复。
-
计数功能：
set.count()返回 0（不存在）或 1（存在）。multiset.count()返回元素的个数。
-
查找与删除：
set直接删除一个值，因其唯一性只影响一个元素。multiset可以删除所有重复的值，也可以通过迭代器删除单个值。
7. 适用场景
-
set：- 当需要存储唯一元素，且自动排序时使用。
- 例如：集合操作、不允许重复的关键字存储等。
-
multiset：- 当需要存储允许重复元素，且元素自动排序时使用。
- 例如：统计数据频率、多重集合等。
8. 总结
| 特性 | set | multiset |
|---|---|---|
| 元素唯一性 | 元素唯一，不允许重复 | 元素可重复 |
| 插入元素 | 插入已存在元素会失败 | 插入元素总是成功 |
| 元素个数 | count() 返回 0 或 1 | count() 返回实际个数 |
| 适用场景 | 唯一集合、去重存储 | 统计频率、多重集合 |
根据具体需求选择使用 set 或 multiset，如果数据允许重复且需要排序，使用 multiset。
8、map和multimap容器
对组：键值对
对组(pair)将一对值组合成一个值，这一对值可以具有不同的数据类型，两个值可以分别用pair的两个公有属性first和second访问。
类模板: template <class T1, class T2> struct pair.
如何创建对组？
// 第一种方法创建一个对组
pair<string, int> pair1(string("name"), 20);
cout << pair1.first << endl; // 访问pair第一个值
cout << pair1.second << endl; // 访问pair第二个值
// 第二种
pair<string, int> pair2 = make_pair("name", 30);
cout << pair2.first << endl;
cout << pair2.second << endl;
// pair赋值
pair<string, int> pair3 = pair2;
cout << pair3.first << endl;
cout << pair3.second << endl;
8.1、map和multimap基本概念
Map的特性是，所有元素都会根据元素的键值自动排序。Map所有的元素都是pair，同时拥有实值和键值，pair的第一元素被视为键值，第二元素被视为实值，map不允许两个元素有相同的键值。
我们可以通过map的迭代器改变map的键值吗？答案是不行，因为map的键值关系到map元素的排列规则，任意改变map键值将会严重破坏map组织。如果想要修改元素的实值，那么是可以的。
Map和list拥有相同的某些性质，当对它的容器元素进行新增操作或者删除操作时，操作之前的所有迭代器，在操作完成之后依然有效，当然被删除的那个元素的迭代器必然是个例外。
Multimap和map的操作类似，唯一区别multimap键值可重复。
Map和multimap都是以红黑树为底层实现机制。
8.2、map和multimap常用操作
-
构造函数
map<T1, T2> mapTT; // map默认构造函数 map(const map &mp); // 拷贝构造函数 -
赋值操作
map& operator=(const map &mp); // 重载等号操作符 swap(mp); // 交换两个集合容器 -
大小操作
size(); // 返回容器中元素的数目 empty(); // 判断容器是否为空 -
插入操作
map.insert(...); // 往容器插入元素，返回pair<iterator, bool> map<int, string> mapStu; // 第一种 通过pair的方式插入对象 mapStu.insert(pair<int, string>(3, "小张")); // 第二种 通过pair的方式插入对象 mapStu.insert(make_pair(-1, "校长")); // 第三种 通过value_type的方式插入对象 mapStu.insert(map<int, string>::value_type(1, "小李")); // 第四种 通过数组的方式插入值 mapStu[3] = "小刘"; mapStu[5] = "小王"; -
删除元素
clear(); // 删除所有元素 erase(pos); // 删除pos迭代器所指的元素，返回下一个元素的迭代器。 erase(beg, end); // 删除区间[beg, end)的所有元素，返回下一个元素的迭代器。 erase(keyElem); // 删除容器中key为keyElem的对组。 -
查找操作
find(key); // 查找键key是否存在，若存在，返回该键的元素的迭代器；若不存在，返回map.end()； count(keyElem); // 返回容器中key为keyElem的对组个数。对map来说，要么是0，要么是1。对multimap来说，值可能大于1。 lower_bound(keyElem); // 返回第一个key>=keyElem元素的迭代器。 upper_bound(keyElem); // 返回第一个key>keyElem元素的迭代器。 equal_range(keyElem); // 返回容器中key与keyElem相等的上下限的两个迭代器。
8.3、multimap案例
公司今天招聘了5个员工，5名员工进入公司之后，需要指派员工在那个部门工作
人员信息有：姓名 年龄 电话 工资等组成
通过Multimap进行信息的插入 保存 显示
分部门显示员工信息 显示全部员工信息
#include<iostream>
#include<map>
#include<string>
#include<vector>
using namespace std;
// multimap 案例
// 公司今天招聘了 5 个员工，5 名员工进入公司之后，需要指派员工在那个部门工作
// 人员信息有：姓名 年龄 电话 工资等组成
// 通过 Multimap 进行信息的插入 保存 显示
// 分部门显示员工信息 显示全部员工信息
#define SALE_DEPATMENT 1 //销售部门
#define DEVELOP_DEPATMENT 2 //研发部门
#define FINACIAL_DEPATMENT 3 //财务部门
#define ALL_DEPATMENT 4 //所有部门
//员工类
class person{
public:
string name; //员工姓名
int age; //员工年龄
double salary; //员工工资
string tele; //员工电话
};
//创建5个员工
void CreatePerson(vector<person>& vlist){
string seed = "ABCDE";
for (int i = 0; i < 5; i++){
person p;
p.name = "员工";
p.name += seed[i];
p.age = rand() % 30 + 20;
p.salary = rand() % 20000 + 10000;
p.tele = "010-8888888";
vlist.push_back(p);
}
}
//5名员工分配到不同的部门
void PersonByGroup(vector<person>& vlist, multimap<int, person>& plist){
int operate = -1; //用户的操作
for (vector<person>::iterator it = vlist.begin(); it != vlist.end(); it++){
cout << "当前员工信息:" << endl;
cout << "姓名: " << it->name << " 年龄:" << it->age << " 工资:" << it->salary << " 电话: " << it->tele << endl;
cout << "请对该员工进行部门分配(1 销售部门, 2 研发部门, 3 财务部门):" << endl;
scanf("%d", &operate);
while (true){
if (operate == SALE_DEPATMENT){ //将该员工加入到销售部门
plist.insert(make_pair(SALE_DEPATMENT, *it));
break;
}
else if (operate == DEVELOP_DEPATMENT){
plist.insert(make_pair(DEVELOP_DEPATMENT, *it));
break;
}
else if (operate == FINACIAL_DEPATMENT){
plist.insert(make_pair(FINACIAL_DEPATMENT, *it));
break;
}
else{
cout << "您的输入有误，请重新输入(1 销售部门, 2 研发部门, 3 财务部门):" << endl;
scanf("%d", &operate);
}
}
}
cout << "员工部门分配完毕!" << endl;
cout << "************************************************************************" << endl;
}
//打印员工信息
void printList(multimap<int, person>& plist, int myoperate)
{
if (myoperate == ALL_DEPATMENT)
{
for (multimap<int, person>::iterator it = plist.begin(); it != plist.end(); it++)
{
cout << "姓名: " << it->second.name << " 年龄:" << it->second.age << " 工资:" << it->second.salary << " 电话: " << it->second.tele << endl;
}
return;
}
multimap<int, person>::iterator it = plist.find(myoperate);
int depatCount = plist.count(myoperate);
int num = 0;
if (it != plist.end())
{
while (it != plist.end() && num < depatCount)
{
cout << "姓名: " << it->second.name << " 年龄:" << it->second.age << " 工资:" << it->second.salary << " 电话: " << it->second.tele << endl;
it++;
num++;
}
}
}
//根据用户操作显示不同部门的人员列表
void ShowPersonList(multimap<int, person>& plist, int myoperate)
{
switch (myoperate)
{
case SALE_DEPATMENT:
printList(plist, SALE_DEPATMENT);
break;
case DEVELOP_DEPATMENT:
printList(plist, DEVELOP_DEPATMENT);
break;
case FINACIAL_DEPATMENT:
printList(plist, FINACIAL_DEPATMENT);
break;
case ALL_DEPATMENT:
printList(plist, ALL_DEPATMENT);
break;
}
}
//用户操作菜单
void PersonMenue(multimap<int, person>& plist)
{
int flag = -1;
int isexit = 0;
while (true)
{
cout << "请输入您的操作(1 销售部门, 2 研发部门, 3 财务部门, 4 所有部门, 0退出): " << endl;
scanf("%d", &flag);
switch (flag)
{
case SALE_DEPATMENT:
ShowPersonList(plist, SALE_DEPATMENT);
break;
case DEVELOP_DEPATMENT:
ShowPersonList(plist, DEVELOP_DEPATMENT);
break;
case FINACIAL_DEPATMENT:
ShowPersonList(plist, FINACIAL_DEPATMENT);
break;
case ALL_DEPATMENT:
ShowPersonList(plist, ALL_DEPATMENT);
break;
case 0:
isexit = 1;
break;
default:
cout << "您的输入有误，请重新输入!" << endl;
break;
}
if (isexit == 1)
break;
}
}
int main()
{
vector<person> vlist; //创建的5个员工 未分组
multimap<int, person> plist; //保存分组后员工信息
//创建5个员工
CreatePerson(vlist);
//5名员工分配到不同的部门
PersonByGroup(vlist, plist);
//根据用户输入显示不同部门员工信息列表 或者 显示全部员工的信息列表
PersonMenue(plist);
system("pause");
return EXIT_SUCCESS;
}
map和multimap容器的区别
map 和 multimap 是 C++ STL 中的关联容器，它们用于存储键值对（key-value）数据，但两者在键的唯一性和数据存储规则上存在区别。
1. 概述
-
map：- 键（Key）唯一，不允许重复。
- 每个键只能对应一个值（
key-value对唯一）。 - 默认按键升序排序（可以自定义比较规则）。
-
multimap：- 键（Key）允许重复，即可以有多个相同的键。
- 适合存储多个相同键但不同值的数据。
- 同样默认按键升序排序（可自定义规则）。
2. 内部实现
- 两者底层均采用红黑树（平衡二叉搜索树）实现，保证了高效的插入、删除和查找操作，时间复杂度为 O(log n)。
- 区别：
map插入时会检查键是否已存在，存在则插入失败。multimap不检查键是否重复，直接插入新元素。
3. 特性对比
| 特性 | map | multimap |
|---|---|---|
| 键的唯一性 | 键唯一，不允许重复 | 键允许重复 |
| 插入操作 | 插入已存在键时失败（不替换） | 插入相同键总是成功 |
| 访问元素 | 通过 [] 运算符直接访问 | 不支持 [] 运算符，需要通过迭代器 |
| 元素个数 | 每个键只能对应一个值 | 每个键可以对应多个值 |
| 删除操作 | 删除键会删除对应的唯一值 | 删除键会删除所有匹配的键值对 |
| 查找操作 | find() 返回唯一的迭代器 | find() 返回第一个匹配的迭代器 |
| 计数操作 | count() 返回 0 或 1 | count() 返回键的数量 |
4. 示例代码
map 示例
#include <iostream>
#include <map>
using namespace std;
int main() {
map<int, string> m;
// 插入元素
m.insert({1, "Apple"});
m.insert({2, "Banana"});
m.insert({2, "Orange"}); // 键 2 已存在，插入失败
// 访问元素
cout << "键 1 对应的值: " << m[1] << endl;
// 遍历 map
for (const auto &pair : m) {
cout << pair.first << ": " << pair.second << endl;
}
return 0;
}
输出结果：
键 1 对应的值: Apple
1: Apple
2: Banana
说明：
map中键不能重复，所以插入第二个键为2的元素时插入失败。
multimap 示例
#include <iostream>
#include <map>
using namespace std;
int main() {
multimap<int, string> mm;
// 插入元素
mm.insert({1, "Apple"});
mm.insert({2, "Banana"});
mm.insert({2, "Orange"}); // 允许重复键
// 遍历 multimap
cout << "multimap 中的元素:" << endl;
for (const auto &pair : mm) {
cout << pair.first << ": " << pair.second << endl;
}
// 查找所有键为 2 的元素
auto range = mm.equal_range(2);
cout << "键为 2 的元素:" << endl;
for (auto it = range.first; it != range.second; ++it) {
cout << it->first << ": " << it->second << endl;
}
return 0;
}
输出结果：
multimap 中的元素:
1: Apple
2: Banana
2: Orange
键为 2 的元素:
2: Banana
2: Orange
说明：
multimap允许重复键，插入了两个键为2的元素。- 使用
equal_range()查找键2对应的所有元素。
5. 关键区别总结
-
键的唯一性：
map：键唯一，不允许重复。multimap：键可以重复。
-
插入元素：
map：插入已存在的键时失败，不会替换原值。multimap：允许插入相同键的多个值。
-
访问元素：
map：支持[]运算符访问值，例如m[key]。multimap：不支持[]，需要通过迭代器访问。
-
查找元素：
map：find()返回键的唯一元素。multimap：find()返回第一个匹配的元素，使用equal_range()查找所有匹配的键。
-
删除操作：
map：删除一个键值对，键是唯一的。multimap：删除键会删除所有匹配的键值对。
6. 适用场景
-
map：- 用于存储键唯一的数据，例如字典、用户 ID 对应用户信息等。
- 适合需要快速查找、插入和删除操作的场景。
-
multimap：- 用于存储键可重复的数据，例如统计多种类型的学生成绩、分类数据等。
- 适合需要处理重复键值的场景。
7. 总结表格
| 特性 | map | multimap |
|---|---|---|
| 键的唯一性 | 键唯一 | 键允许重复 |
| 访问元素 | 支持 [] 运算符 | 不支持 [] 运算符 |
| 插入相同键 | 插入失败 | 插入成功，允许多个相同键的值 |
| 查找元素 | 返回单个元素 | 返回第一个匹配元素，可用 equal_range() 查找所有 |
| 适用场景 | 唯一键值对存储 | 键值对允许重复的存储 |
根据场景需求：
- 如果键唯一，使用
map。 - 如果键可能重复，使用
multimap。
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
