• C++从入门到精通 第十四章（STL容器）【上】

     写在前面：

    1. 本系列专栏主要介绍C++的相关知识，思路以下面的参考链接教程为主，大部分笔记也出自该教程，笔者的原创部分主要在示例代码的注释部分。
    2. 除了参考下面的链接教程以外，笔者还参考了其它的一些C++教材（比如计算机二级教材和C语言教材），笔者认为重要的部分大多都会用粗体标注（未被标注出的部分可能全是重点，可根据相关部分的示例代码量和注释量判断，或者根据实际经验判断）。
    3. 如有错漏欢迎指出。

    参考教程：黑马程序员匠心之作|C++教程从0到1入门编程,学习编程不再难_哔哩哔哩_bilibili

    一、string容器

    1、string容器概述

    （1）string的本质：string是C++风格的字符串，而string本质上是一个类。

    （2）string和char *的区别：char *是一个指针，而string是一个类，类内部封装了char*，管理这个字符串，是一个char*型的容器。

    （3）string 类内部封装了很多成员方法，例如查找find、拷贝copy、删除delete、替换replace、插入insert。

    （4）string管理char*所分配的内存，不用担心复制越界和取值越界等，由类内部进行负责。

    2、string类的构造函数

    string();                //创建一个空的字符串（默认构造）

    string(const string& str);   //使用一个string对象初始化另一个string对象（拷贝构造）

    string(int n, char c);       //使用n个字符c初始化string对象

    1. #include
    2. #include
    3. using namespace std;
    4.  
    5. void test01()  
    6. {
    7. 	string s1;      //默认构造
    8.  
    9. 	const char * str = "Hello world";    //使用字符串初始化
    10. 	string s2(str);                      //这个也可视作拷贝构造
    11. 	cout << "s2 : " << s2 << endl;
    12.  
    13. 	string s3(s2);   //拷贝构造
    14. 	cout << "s2 : " << s2 << endl;
    15.  
    16. 	string s4(10, 'a');   //使用n个字符初始化
    17. 	cout << "s4 : " << s4 << endl;
    18. }
    19.  
    20. int main() {
    21.  
    22. 	test01();
    23.  
    24. 	system("pause");
    25.  
    26. 	return 0;
    27. }

    3、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组成字符串赋给当前的字符串

    1. #include
    2. #include
    3. using namespace std;
    4. #include
    5.  
    6. void test01()   
    7. {
    8. 	string str1;
    9. 	str1 = "Hello world";
    10. 	cout << "srt1 = " << str1 << endl;
    11.  
    12. 	string str2;
    13. 	str2 = str1;
    14. 	cout << "srt2 = " << str2 << endl;
    15.  
    16. 	string str3;
    17. 	str3 = 'a';
    18. 	cout << "srt3 = " << str3 << endl;
    19.  
    20. 	string str4;
    21. 	str4.assign("Hello C++");
    22. 	cout << "srt4 = " << str4 << endl;
    23.  
    24. 	string str5;
    25. 	str5.assign("Hello C++", 5);
    26. 	cout << "srt5 = " << str5 << endl;
    27.  
    28. 	string str6;
    29. 	str6.assign(str5);
    30. 	cout << "srt6 = " << str6 << endl;
    31.  
    32. 	string str7;
    33. 	str7.assign(10, 'w');
    34. 	cout << "srt7 = " << str7 << endl;
    35. }
    36.  
    37. int main() {
    38.  
    39. 	test01();
    40.  
    41. 	system("pause");
    42.  
    43. 	return 0;
    44. }

    4、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个字符连接到字符串结尾

    1. #include
    2. #include
    3. using namespace std;
    4.  
    5. void test01()   
    6. {
    7. 	string str1;
    8. 	str1 = "我";
    9. 	str1 += "爱玩游戏";
    10. 	cout << "str1 = " << str1 << endl;
    11. 	str1 += ':';
    12. 	cout << "str1 = " << str1 << endl;
    13. 	string str2 = " LOL DNF";
    14. 	str1 += str2;
    15. 	cout << "str1 = " << str1 << endl;
    16.  
    17. 	string str3 = "I";
    18. 	str3.append(" love ");
    19. 	cout << "str3 = " << str3 << endl;
    20. 	str3.append("Python abcde", 6);
    21. 	cout << "str3 = " << str3 << endl;
    22. 	str3.append(str2);
    23. 	cout << "str3 = " << str3 << endl;
    24. 	str3.append(str2, 0, 4);     //参数2：从哪个位置开始截取
    25. 	cout << "str3 = " << str3 << endl;
    26. 	str3.append(str2, 4, 4);     //参数3：截取字符个数
    27. 	cout << "str3 = " << str3 << endl;
    28. }
    29.  
    30. int main() {
    31.  
    32. 	test01();
    33.  
    34. 	system("pause");
    35.  
    36. 	return 0;
    37. }

    5、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

    1. #include
    2. #include
    3. using namespace std;
    4.  
    5. void test01()     //查找
    6. {
    7. 	string str1 = "abcdefgcd";        //该字符串有两个“cd”
    8. 	int pos = str1.find("cd");      //find从左往右查
    9. 	if (pos == -1)
    10. 	{
    11. 		cout << "未找到字符串" << endl;
    12. 	}
    13. 	else
    14. 	{
    15. 		cout << "pos = " << pos << endl;
    16. 	}
    17. 	pos = str1.find("df");
    18. 	if (pos == -1)
    19. 	{
    20. 		cout << "未找到字符串" << endl;
    21. 	}
    22. 	else
    23. 	{
    24. 		cout << "pos = " << pos << endl;
    25. 	}
    26. 	
    27. 	pos = str1.rfind("cd");       //rfind从右往左查（位置编号还是从左往右算）
    28. 	cout << "pos = " << pos << endl;
    29. 	
    30. }
    31.  
    32. void test02()     //替换
    33. {
    34. 	string str1 = "abcdefg";
    35. 	str1.replace(2, 3, "kkkk");    //从2号位置起的3个字符替换为“kkkk”
    36. 	cout << "str1 = " << str1 << endl;
    37. }
    38.  
    39. int main() {
    40.  
    41. 	test01();
    42. 	test02();
    43.  
    44. 	system("pause");
    45.  
    46. 	return 0;
    47. }

    6、string字符串比较函数

    比较方式：字符串比较是从第一个字符开始，按字符的ASCII码进行对比，只要出现同位置字符ASCII码不同的情况，那么两个字符串就不相等，认为ASCII码较大的一个字符串更大。

    ①比较结果为“=”，返回0。

    ②比较结果为“>”，返回1。

    ③比较结果为“<”，返回-1。

    int compare(const string &s) const;  //与字符串s比较

    int compare(const char *s) const;   //与字符串s比较

    1. #include
    2. #include
    3. using namespace std;
    4.  
    5. string compare(string &str1,string &str2)
    6. {
    7. 	if (str1.compare(str2) == 0)
    8. 	{
    9. 		return " 等于= ";
    10. 	}
    11. 	else if (str1.compare(str2) == 1)
    12. 	{
    13. 		return " 大于> ";
    14. 	}
    15. 	else if(str1.compare(str2) == -1)
    16. 	{
    17. 		return " 小于< ";
    18. 	}
    19. }
    20.  
    21. void test01()     
    22. {
    23. 	string str1 = "hello";
    24. 	string str2 = "hello";
    25. 	string str3 = "xello";
    26. 	string str4 = "heklo";
    27. 	cout << "str1" << compare(str1, str2) << "str2" << endl;
    28. 	cout << "str1" << compare(str1, str3) << "str3" << endl;
    29. 	cout << "str1" << compare(str1, str4) << "str4" << endl;
    30. }
    31.  
    32. int main() {
    33.  
    34. 	test01();
    35.  
    36. 	system("pause");
    37.  
    38. 	return 0;
    39. }

    7、string字符串的字符存取

    string字符串中单个字符存取方式有两种：

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

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

    1. #include
    2. #include
    3. using namespace std;
    4.  
    5. void test01()     
    6. {
    7. 	string str = "Hello world";
    8. 	//通过[]访问单个字符
    9. 	for (int i = 0; i < str.size(); i++)
    10. 	{
    11. 		cout << str[i] << " ";
    12. 	}
    13. 	cout << endl;
    14. 	str[0] = 'h';
    15. 	//通过at方式访问单个字符
    16. 	for (int i = 0; i < str.size(); i++)
    17. 	{
    18. 		cout << str.at(i) << " ";
    19. 	}
    20. 	cout << endl;
    21. 	str.at(0) = 'H';
    22. 	for (int i = 0; i < str.size(); i++)
    23. 	{
    24. 		cout << str.at(i) << " ";
    25. 	}
    26. 	cout << endl;
    27. }
    28.  
    29. int main() {
    30.  
    31. 	test01();
    32.  
    33. 	system("pause");
    34.  
    35. 	return 0;
    36. }

    8、string字符串的字符插入和字符删除

    对string字符串进行插入和删除操作时，要将string字符串视为字符数组，起始的下标都是从0开始算

    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个字符

    1. #include
    2. #include
    3. using namespace std;
    4.  
    5. void test01()     
    6. {
    7. 	string str = "Hello";
    8. 	str.insert(1, "k2k");   //插入
    9. 	cout << "str = " << str << endl;
    10. 	str.erase(1, 3);        //删除
    11. 	cout << "str = " << str << endl;
    12. }
    13.  
    14. int main() {
    15.  
    16. 	test01();
    17.  
    18. 	system("pause");
    19.  
    20. 	return 0;
    21. }

    9、从字符串string获取子串

    string substr(int pos = 0, int n = npos) const; //返回由pos开始的n个字符组成的字符串

    1. #include
    2. #include
    3. using namespace std;
    4.  
    5. void test01()     
    6. {
    7. 	string str = "abcdefg";
    8. 	string subStr = str.substr(1, 3);
    9. 	cout << "subStr = " << subStr << endl;
    10. }
    11. void test02()
    12. {
    13. 	string email = "zhangsan@sina.com";
    14. 	int pos = email.find("@");
    15. 	string usrName = email.substr(0, pos);
    16. 	cout << "usrName = " << usrName << endl;
    17. }
    18.  
    19. int main() {
    20.  
    21. 	test01();
    22. 	test02();
    23.  
    24. 	system("pause");
    25.  
    26. 	return 0;
    27. }

    二、vector容器

    1、vector的基本概念

    （1）vector数据结构和数组非常相似，也称为单端数组。

    （2）vector与普通数组区别：数组是静态空间，而vector可以动态扩展，而动态扩展并不是在原空间之后续接新空间，而是找更大的内存空间，然后将原数据拷贝新空间，释放原空间。

    （3）vector容器的迭代器是支持随机访问的迭代器。

    2、vector的构造函数

    vector v;              //采用模板实现类实现，默认构造函数

    vector(v.begin(), v.end());    //将v[begin(), end())区间中的元素拷贝给本身

    vector(n, elem);           //构造函数将n个elem拷贝给本身

    vector(const vector &vec);  //拷贝构造函数

    1. #include
    2. #include
    3. using namespace std;
    4.  
    5. void printVector(vector<int> &v)
    6. {
    7. 	for (vector<int>::iterator it = v.begin(); it != v.end(); it++)
    8. 	{
    9. 		cout << *it << "  ";
    10. 	}
    11. 	cout << endl;
    12. }
    13.  
    14. void test01()     
    15. {
    16. 	vector<int> v1;                          //默认构造（无参构造）
    17. 	for (int i = 0; i < 10; i++)
    18. 	{
    19. 		v1.push_back(i);
    20. 	}
    21. 	printVector(v1);
    22. 	vector<int> v2(v1.begin(), v1.end());    //通过区间方式进行构造
    23. 	printVector(v2);
    24. 	vector<int> v3(10, 199);                 //n个elem方式构造
    25. 	printVector(v3);
    26. 	vector<int> v4(v3);                      //拷贝构造
    27. 	printVector(v4);
    28. }
    29.  
    30. int main() {
    31.  
    32. 	test01();
    33.  
    34. 	system("pause");
    35.  
    36. 	return 0;
    37. }

    3、vector的赋值操作

    vector& operator=(const vector &vec); //重载等号操作符

    assign(beg, end);                  //将[beg, end)区间中的数据拷贝赋值给本身

    assign(n, elem);                   //将n个elem拷贝赋值给本身

    1. #include
    2. #include
    3. using namespace std;
    4.  
    5. void printVector(vector<int> &v)
    6. {
    7. 	for (vector<int>::iterator it = v.begin(); it != v.end(); it++)
    8. 	{
    9. 		cout << *it << "  ";
    10. 	}
    11. 	cout << endl;
    12. }
    13.  
    14. void test01()     
    15. {
    16. 	vector<int> v1;
    17. 	for (int i = 0; i < 10; i++)
    18. 	{
    19. 		v1.push_back(i);
    20. 	}
    21. 	printVector(v1);
    22. 	vector<int>v2;
    23. 	v2 = v1;          //赋值 operator=
    24. 	printVector(v2);
    25. 	vector<int>v3;
    26. 	v3.assign(v1.begin(), v1.end());   //赋值 assign
    27. 	printVector(v3);
    28. 	vector<int>v4;
    29. 	v4.assign(10, 51);                 //赋值 n个elem方式
    30. 	printVector(v4);
    31. }
    32.  
    33. int main() {
    34.  
    35. 	test01();
    36.  
    37. 	system("pause");
    38.  
    39. 	return 0;
    40. }

    4、vector的容量和大小

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

    capacity();     //容器的容量

    size();         //返回容器中元素的个数

    resize(int num); //重新指定容器的长度为num，若容器变长，则以默认值填充新位置

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

    resize(int num, elem); //重新指定容器的长度为num，若容器变长，则以elem值填充新位置

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

    1. #include
    2. #include
    3. using namespace std;
    4.  
    5. void printVector(vector<int> &v)
    6. {
    7. 	for (vector<int>::iterator it = v.begin(); it != v.end(); it++)
    8. 	{
    9. 		cout << *it << "  ";
    10. 	}
    11. 	cout << endl;
    12. }
    13.  
    14. void test01()     
    15. {
    16. 	vector<int> v1,v2;
    17. 	if (v1.empty())
    18. 	{
    19. 		cout << "容器v1为空" << endl;
    20. 	}
    21. 	cout << endl;
    22. 	for (int i = 0; i < 10; i++)
    23. 	{
    24. 		v1.push_back(i);
    25. 	}
    26. 	printVector(v1);
    27. 	if (v1.empty())
    28. 	{
    29. 		cout << "容器v1为空" << endl;
    30. 	}
    31. 	else
    32. 	{
    33. 		cout << "容器v1不为空" << endl;
    34. 		cout << "v1的容量为" << v1.capacity() << endl;
    35. 		cout << "v1的元素个数为" << v1.size() << endl;
    36. 	}
    37. 	v1.resize(15);
    38. 	printVector(v1);    //如果重新指定的长度比原来长了，默认用0填充新位置
    39. 	cout << "v1的容量为" << v1.capacity() << endl;
    40. 	cout << "v1的元素个数为" << v1.size() << endl;
    41. 	v2 = v1;
    42. 	v2.resize(8);
    43. 	printVector(v2);    //如果重新指定的长度比原来短，则超出长度的元素会被删除
    44. 	v2.resize(12, 10);
    45. 	printVector(v2);    //重新指定容器的长度，若容器变长，则以elem值填充新位置
    46. }
    47.  
    48. int main() {
    49.  
    50. 	test01();
    51.  
    52. 	system("pause");
    53.  
    54. 	return 0;
    55. }

    5、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();                                //删除容器中所有元素

    1. #include
    2. #include
    3. using namespace std;
    4.  
    5. void printVector(vector<int> &v)
    6. {
    7. 	int j = 0;
    8. 	for (vector<int>::iterator it = v.begin(); it != v.end(); it++)
    9. 	{
    10. 		cout << *it << "  ";
    11. 		j++;
    12. 	}
    13. 	if (j == 0)
    14. 	{
    15. 		cout << "什么也没有" << endl;
    16. 	}
    17. 	cout << endl;
    18. }
    19.  
    20. void test01()     
    21. {
    22. 	vector<int> v1;
    23. 	v1.push_back(10);  //尾插
    24. 	v1.push_back(20);
    25. 	v1.push_back(30);
    26. 	v1.push_back(40);
    27. 	v1.push_back(50);
    28. 	printVector(v1);
    29. 	v1.pop_back();    //尾删
    30. 	printVector(v1);
    31. 	v1.insert(v1.begin(), 100);   //插入  第一个参数是迭代器
    32. 	printVector(v1);
    33. 	v1.insert(v1.begin(), 2 ,100);
    34. 	printVector(v1);
    35. 	v1.erase(v1.begin());         //删除 参数是迭代器
    36. 	printVector(v1);
    37. 	v1.erase(v1.begin(), v1.end());   //v1.clear();具有同等作用
    38. 	printVector(v1);
    39. }
    40.  
    41. int main() {
    42.  
    43. 	test01();
    44.  
    45. 	system("pause");
    46.  
    47. 	return 0;
    48. }

    6、vector的数据存取

    at(int idx);   //返回索引idx所指的数据

    operator[];  //返回索引idx所指的数据

    front();     //返回容器中第一个数据元素

    back();     //返回容器中最后一个数据元素

    1. #include
    2. #include
    3. using namespace std;
    4.  
    5. void test01()     
    6. {
    7. 	vector<int> v1;
    8. 	for (int i = 0; i < 10; i++)
    9. 	{
    10. 		v1.push_back(i);
    11. 	}
    12. 	//利用[]方式访问数组元素
    13. 	for (int i = 0; i < v1.size(); i++)
    14. 	{
    15. 		cout << v1[i] << " ";
    16. 	}
    17. 	cout << endl;
    18. 	//利用at方式访问元素
    19. 	for (int i = 0; i < v1.size(); i++)
    20. 	{
    21. 		cout << v1.at(i) << " ";
    22. 	}
    23. 	cout << endl;
    24. 	cout << "第一个元素为： " << v1.front() << endl;
    25. 	cout << "最后一个元素为： " << v1.back() << endl;
    26. }
    27.  
    28. int main() {
    29.  
    30. 	test01();
    31.  
    32. 	system("pause");
    33.  
    34. 	return 0;
    35. }

    7、vector的互换容器操作

    swap(vec);   //将vec中的元素与调用该函数的对象本身的元素互换

    1. #include
    2. #include
    3. using namespace std;
    4.  
    5. void printVector(vector<int> &v)
    6. {
    7. 	for (vector<int>::iterator it = v.begin(); it != v.end(); it++)
    8. 	{
    9. 		cout << *it << "  ";
    10. 	}
    11. 	cout << endl;
    12. }
    13.  
    14. void test01()     
    15. {
    16. 	cout << "交换前：" << endl;
    17. 	vector<int> v1;
    18. 	for (int i = 0; i < 10; i++)
    19. 	{
    20. 		v1.push_back(i * 10);
    21. 	}
    22. 	printVector(v1);
    23. 	vector<int> v2;
    24. 	for (int i = 9; i > -1; i--)
    25. 	{
    26. 		v2.push_back(i * 10);
    27. 	}
    28. 	printVector(v2);
    29. 	cout << "交换后：" << endl;
    30. 	v1.swap(v2);
    31. 	printVector(v1);
    32. 	printVector(v2);
    33. }
    34.  
    35. void test02()      //巧用swap可以收缩内存空间
    36. {
    37. 	vector<int>v;
    38. 	for (int i = 0; i < 100000; i++)
    39. 	{
    40. 		v.push_back(i);
    41. 	}
    42. 	cout << "v的容量为：" << v.capacity() << endl;
    43. 	cout << "v的大小为：" << v.size() << endl;
    44. 	v.resize(3);   //重新指定大小
    45. 	cout << "v的容量为：" << v.capacity() << endl;   //容量不会变小
    46. 	cout << "v的大小为：" << v.size() << endl;
    47. 	vector<int>(v).swap(v);            //vector(v)--匿名对象，按照v的元素给它初始化，本行过后匿名对象被销毁
    48. 	cout << "v的容量为：" << v.capacity() << endl;   //容量变小
    49. 	cout << "v的大小为：" << v.size() << endl;
    50. }
    51.  
    52. int main() {
    53.  
    54. 	test01();
    55. 	test02();
    56.  
    57. 	system("pause");
    58.  
    59. 	return 0;
    60. }

    8、vector允许预留空间

    预留空间也就是先在内存划分一片属于vector对象的空间，这部分空间可以不立即使用，这样可以减少vector在动态扩展容量时的扩展次数。

    reserve(int len);   //容器预留len个元素长度，预留位置不初始化，元素不可访问

    1. #include
    2. #include
    3. using namespace std;
    4.  
    5. void test01()     
    6. {
    7. 	vector<int> v;
    8. 	v.reserve(100000);   //预留空间
    9. 	int num = 0;    //统计开辟内存次数
    10. 	int *p = NULL;
    11. 	for (int i = 0; i < 100000; i++)
    12. 	{
    13. 		v.push_back(i);
    14. 		if (p != &v[0])
    15. 		{
    16. 			p = &v[0];
    17. 			num++;
    18. 		}
    19. 	}
    20. 	cout << "num = " << num << endl;
    21. }
    22.  
    23. int main() {
    24.  
    25. 	test01();
    26.  
    27. 	system("pause");
    28.  
    29. 	return 0;
    30. }

    三、deque容器

    1、deque容器的基本概念

    （1）deque容器是一个双端数组，可以对头端进行插入删除操作。

    （2）deque与vector的区别：

    ①vector在头部插入或删除元素的效率低，数据量越大，效率越低。

    ②deque在头部插入元素或删除元素的速度比vector快。

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

    （3）deque内部的工作原理：

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

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

    （4）deque容器的迭代器也是支持随机访问的。

    2、deque的构造函数

    deque deqT;           //默认构造形式

    deque(beg, end);          //构造函数将[beg, end)区间中的元素拷贝给本身

    deque(n, elem);           //构造函数将n个elem拷贝给本身

    deque(const deque &deq);  //拷贝构造函数

    1. #include
    2. #include
    3. using namespace std;
    4.  
    5. void printDeque(const deque<int> &d)
    6. {
    7. 	for (deque<int>::const_iterator it = d.begin(); it != d.end(); it++)
    8. 	{
    9. 		//*it = 100;   容器中的数据不可以修改了
    10. 		cout << *it << "  ";
    11. 	}
    12. 	cout << endl;
    13. }
    14.  
    15. void test01()     
    16. {
    17. 	deque<int>d1;
    18. 	for (int i = 0; i < 10; i++)
    19. 	{
    20. 		d1.push_back(i);
    21. 	}
    22. 	printDeque(d1);
    23. 	deque<int>d2(d1.begin(), d1.end());
    24. 	printDeque(d2);
    25. 	deque<int>d3(10, 100);
    26. 	printDeque(d3);
    27. 	deque<int>d4(d3);
    28. 	printDeque(d4);
    29. }
    30.  
    31. int main() {
    32.  
    33. 	test01();
    34.  
    35. 	system("pause");
    36.  
    37. 	return 0;
    38. }

    3、deque的赋值操作

    deque& operator=(const deque &deq);  //重载等号操作符

    assign(beg, end);                    //将[beg, end)区间中的数据拷贝赋值给本身

    assign(n, elem);                     //将n个elem拷贝赋值给本身

    1. #include
    2. #include
    3. using namespace std;
    4.  
    5. void printDeque(const deque<int> &d)
    6. {
    7. 	for (deque<int>::const_iterator it = d.begin(); it != d.end(); it++)
    8. 	{
    9. 		cout << *it << "  ";
    10. 	}
    11. 	cout << endl;
    12. }
    13.  
    14. void test01()     
    15. {
    16. 	deque<int>d1;
    17. 	for (int i = 0; i < 10; i++)
    18. 	{
    19. 		d1.push_back(i);
    20. 	}
    21. 	printDeque(d1);
    22.  
    23. 	//operator=赋值
    24. 	deque<int>d2;
    25. 	d2 = d1;
    26. 	printDeque(d2);
    27.  
    28. 	//assign赋值
    29. 	deque<int>d3;
    30. 	d3.assign(d1.begin(), d1.end());
    31. 	printDeque(d3);
    32.  
    33. 	//n个elem方式赋值
    34. 	deque<int>d4(10, 100);
    35. 	printDeque(d4);
    36. }
    37.  
    38. int main() {
    39.  
    40. 	test01();
    41.  
    42. 	system("pause");
    43.  
    44. 	return 0;
    45. }

    4、deque的大小

    deque.empty();    //判断容器是否为空

    deque.size();      //返回容器中元素的个数

    deque.resize(num); //重新指定容器的长度为num，若容器变长，则以默认值填充新位置

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

    deque.resize(num, elem); //重新指定容器的长度为num，若容器变长，则以elem值填充新位置

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

    1. #include
    2. #include
    3. using namespace std;
    4.  
    5. void printDeque(const deque<int> &d)
    6. {
    7. 	for (deque<int>::const_iterator it = d.begin(); it != d.end(); it++)
    8. 	{
    9. 		cout << *it << "  ";
    10. 	}
    11. 	cout << endl;
    12. }
    13.  
    14. void test01()     
    15. {
    16. 	deque<int>d1;
    17. 	for (int i = 0; i < 10; i++)
    18. 	{
    19. 		d1.push_back(i);
    20. 	}
    21. 	printDeque(d1);
    22. 	if (d1.empty())
    23. 	{
    24. 		cout << "容器d1为空" << endl;
    25. 	}
    26. 	cout << "d1中的元素个数为：" << d1.size() << endl;   //deque没有“容量”的概念
    27. 	d1.resize(15);
    28. 	printDeque(d1);
    29. 	d1.resize(8);
    30. 	printDeque(d1);
    31. 	d1.resize(15, 1);
    32. 	printDeque(d1);
    33. }
    34.  
    35. int main() {
    36.  
    37. 	test01();
    38.  
    39. 	system("pause");
    40.  
    41. 	return 0;
    42. }

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

    1. #include
    2. #include
    3. using namespace std;
    4.  
    5. void printDeque(const deque<int> &d)
    6. {
    7. 	for (deque<int>::const_iterator it = d.begin(); it != d.end(); it++)
    8. 	{
    9. 		cout << *it << "  ";
    10. 	}
    11. 	cout << endl;
    12. }
    13.  
    14. void test01()     
    15. {
    16. 	deque<int>d1;
    17. 	for (int i = 0; i < 10; i++)
    18. 	{
    19. 		d1.push_back(i);      //尾插
    20. 		d1.push_front(i * 2); //头插
    21. 	}
    22. 	printDeque(d1);
    23. 	d1.pop_back();
    24. 	printDeque(d1);
    25. 	d1.pop_front();
    26. 	printDeque(d1);
    27. }
    28. void test02()
    29. {
    30. 	deque<int>d1;
    31. 	for (int i = 0; i < 10; i++)
    32. 	{
    33. 		d1.push_back(i);
    34. 	}
    35. 	d1.insert(d1.begin(), 30);
    36. 	printDeque(d1);
    37. 	d1.insert(d1.begin(), 2, 40);
    38. 	printDeque(d1);
    39. 	deque<int>d2;
    40. 	for (int i = 0; i < 10; i++)
    41. 	{
    42. 		d2.push_front(i);
    43. 	}
    44. 	d1.insert(d1.begin()+1, d2.begin(), d2.end());
    45. 	printDeque(d1);
    46. }
    47. void test03()
    48. {
    49. 	deque<int>d1;
    50. 	for (int i = 0; i < 10; i++)
    51. 	{
    52. 		d1.push_back(i);
    53. 	}
    54. 	d1.erase(++d1.begin());
    55. 	printDeque(d1);
    56. 	d1.erase(d1.begin(), d1.end());   //d1.clear();具有同等作用
    57. 	printDeque(d1);
    58. }
    59.  
    60. int main() {
    61.  
    62. 	test01();
    63. 	cout << endl;
    64. 	test02();
    65. 	cout << endl;
    66. 	test03();
    67.  
    68. 	system("pause");
    69.  
    70. 	return 0;
    71. }

    6、deque的数据存取

    at(int idx);  //返回索引idx所指的数据

    operator[];  //返回索引idx所指的数据

    front();     //返回容器中第一个数据元素

    back();     //返回容器中最后一个数据元素

    1. #include
    2. #include
    3. using namespace std;
    4.  
    5. void test01()     
    6. {
    7. 	deque<int>d1;
    8. 	for (int i = 0; i < 10; i++)
    9. 	{
    10. 		d1.push_back(i);      //尾插
    11. 		d1.push_front(i * 2); //头插
    12. 	}
    13. 	//通过[]方式访问元素
    14. 	for (int i = 0; i < d1.size(); i++)
    15. 	{
    16. 		cout << d1[i] << " ";
    17. 	}
    18. 	cout << endl;
    19. 	//通过at方式访问元素
    20. 	for (int i = 0; i < d1.size(); i++)
    21. 	{
    22. 		cout << d1.at(i) << " ";
    23. 	}
    24. 	cout << endl;
    25. 	cout << "第一个元素为：" << d1.front() << endl;
    26. 	cout << "最后一个元素为：" << d1.back() << endl;
    27. }
    28.  
    29. int main() {
    30.  
    31. 	test01();
    32.  
    33. 	system("pause");
    34.  
    35. 	return 0;
    36. }

    7、deque的数据排序算法

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

    1. #include
    2. #include
    3. #include
    4. using namespace std;
    5.  
    6. void printDeque(const deque<int> &d)
    7. {
    8. 	for (deque<int>::const_iterator it = d.begin(); it != d.end(); it++)
    9. 	{
    10. 		cout << *it << "  ";
    11. 	}
    12. 	cout << endl;
    13. }
    14.  
    15. void test01()     
    16. {
    17. 	deque<int>d1;
    18. 	for (int i = 0; i < 10; i++)
    19. 	{
    20. 		d1.push_back(i);      //尾插
    21. 		d1.push_front(i * 2); //头插
    22. 	}
    23. 	printDeque(d1);
    24. 	sort(d1.begin(),d1.end());   //升序排序
    25. 	//对于支持随机访问的迭代器的容器，都可以用sort算法直接对其进行排序
    26. 	//vector容器也可以利用sort进行排序
    27. 	printDeque(d1);
    28. }
    29.  
    30. int main() {
    31.  
    32. 	test01();
    33.  
    34. 	system("pause");
    35.  
    36. 	return 0;
    37. }

    8、案例

    （1）案例描述：有5名选手ABCDE，10个评委分别对每一名选手打分，去除最高分，去除评委中最低分，取平均分。

    （2）实现步骤：

    ①创建五名选手，放到vector中。

    ②遍历vector容器，取出来每一个选手，执行for循环，可以把10个评分打分存到deque容器中。

    ③sort算法对deque容器中分数排序，去除最高和最低分。

    ④deque容器遍历一遍，累加总分。

    ⑤获取平均分。

    （3）代码：

    1. #include
    2. #include
    3. #include
    4. #include
    5. #include
    6. #include
    7. using namespace std;
    8.  
    9. /* 案例描述：有5名选手ABCDE，10个评委分别对每一名选手打分，去除最高分，去除评委中最低分，取平均分
    10. 实现步骤：
    11. 创建五名选手，放到vector中
    12. 遍历vector容器，取出来每一个选手，执行for循环，可以把10个评分打分存到deque容器中
    13. sort算法对deque容器中分数排序，去除最高和最低分
    14. deque容器遍历一遍，累加总分
    15. 获取平均分*/
    16.  
    17. class Person
    18. {
    19. public:
    20. 	Person(int score, string name)
    21. 	{
    22. 		m_name = name;
    23. 		m_score = score;
    24. 	}
    25. 	int m_score;
    26. 	string m_name;
    27. };
    28. void createPerson(vector&v)
    29. {
    30. 	string nameSeed = "ABCDE";
    31. 	for (int i = 0; i < 5; i++)
    32. 	{
    33. 		string name = "player_";
    34. 		name += nameSeed[i];
    35. 		int score = 0;
    36. 		Person p(score, name);
    37. 		v.push_back(p);
    38. 	}
    39. }
    40. void setScore(vector&v)
    41. {
    42. 	for (vector::iterator it = v.begin(); it != v.end(); it++)
    43. 	{
    44. 		deque<int>d;
    45. 		for (int i = 0; i < 10; i++)
    46. 		{
    47. 			int score = rand() % 51 + 50;   //int score = [rand() % 51] + 50; []内取值为0~50
    48. 			d.push_back(score);
    49. 		}
    50. 		sort(d.begin(),d.end());
    51. 		d.pop_back();
    52. 		d.pop_front();
    53. 		int sum = 0;
    54. 		for (deque<int>::iterator dit = d.begin(); dit != d.end(); dit++)
    55. 		{
    56. 			sum += *dit;
    57. 		}
    58. 		int avg = sum / d.size();
    59. 		it->m_score = avg;
    60. 	}
    61. }
    62.  
    63. void func()     
    64. {
    65. 	vectorp;
    66. 	createPerson(p);
    67. 	setScore(p);
    68. 	for (vector::iterator it = p.begin(); it != p.end(); it++)
    69. 	{
    70. 		cout << it->m_name << "的最终得分为" << it->m_score << endl;
    71. 	}
    72. }
    73.  
    74. int main() {
    75.  
    76. 	srand((unsigned int)time(NULL));
    77. 	func();
    78.  
    79. 	system("pause");
    80.  
    81. 	return 0;
    82. }

    五、stack容器

    1、stack的基本概念

    （1）stack是一种先进后出（First In Last Out，FILO）的数据结构，它只有一个出口。

    （2）栈中只有顶端的元素才可以被外界使用，因此栈不允许有遍历行为。

    （1）栈中进入数据的过程称为入栈（push），栈中弹出数据的过程称为出栈（pop）。

    2、stack的常用接口

    //构造函数：

    stack stk;          //stack采用模板类实现，stack对象的默认构造形式

    stack(const stack &stk);  //拷贝构造函数

    //赋值操作：

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

    //数据存取：

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

    pop();        //从栈顶移除第一个元素

    top();        //返回栈顶元素

    //大小操作：

    empty();      //判断堆栈是否为空

    size();        //返回栈的大小

    1. #include
    2. #include
    3. using namespace std;
    4.  
    5. void test01()     
    6. {
    7. 	stack<int>s;    //符合先进后出的数据结构
    8.  
    9. 	s.push(10);     //入栈
    10. 	s.push(20);
    11. 	s.push(30);
    12. 	s.push(40);
    13.  
    14. 	while (!s.empty())   //只要栈不为空，查看栈顶，并执行出栈操作
    15. 	{
    16. 		cout << "栈顶元素为：" << s.top() << endl;
    17. 		s.pop();    //出栈
    18. 	}
    19. 	cout << "现在栈的大小为：" << s.size() << endl;
    20. }
    21.  
    22. int main() {
    23.  
    24. 	test01();
    25.  
    26. 	system("pause");
    27.  
    28. 	return 0;
    29. }

    六、queue 容器

    1、queue的基本概念

    （1）Queue是一种先进先出（First In First Out，FIFO）的数据结构，它有两个出口。

    （2）队列容器允许从一端（队尾）新增元素，从另一端（队头）移除元素。

    （3）队列中只有队头和队尾才可以被外界使用，因此队列不允许有遍历行为。

    （4）数据进入队列中的过程称为入队（push），数据从队列中被移出的过程称为出队（pop）。

    2、queue的常用接口

    //构造函数：

    queue que;             //queue采用模板类实现，queue对象的默认构造形式

    queue(const queue &que);   //拷贝构造函数

    //赋值操作：

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

    //数据存取：

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

    pop();        //从队头移除第一个元素

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

    front();       //返回第一个元素

    //大小操作：

    empty();     //判断堆栈是否为空

    size();       //返回栈的大小

    1. #include
    2. #include
    3. using namespace std;
    4.  
    5. class Person
    6. {
    7. public:
    8. 	int age1;
    9. 	int age2;
    10. 	Person(int age1, int age2)
    11. 	{
    12. 		this->age1 = age1;
    13. 		this->age2 = age2;
    14. 	}
    15. };
    16.  
    17. void test01()     
    18. {
    19. 	queueq;       //创建队列
    20. 	Person p1(10, 18);    //准备数据
    21. 	Person p2(20, 38);
    22. 	Person p3(30, 58);
    23. 	Person p4(40, 28);
    24. 	q.push(p1);           //入队
    25. 	q.push(p2);
    26. 	q.push(p3);
    27. 	q.push(p4);
    28. 	cout << "队列大小为：" << q.size() << endl;
    29. 	while (!q.empty())
    30. 	{
    31. 		cout << "队头为： age1 = " << q.front().age1 << "  age2 = " << q.front().age2 << endl;
    32. 		cout << "队尾为： age1 = " << q.back().age1 << "  age2 = " << q.back().age2 << endl;
    33. 		cout << endl;
    34. 		q.pop();          //出队
    35. 	}
    36. 	cout << "队列大小为：" << q.size() << endl;
    37. }
    38.  
    39. int main() {
    40.  
    41. 	test01();
    42.  
    43. 	system("pause");
    44.  
    45. 	return 0;
    46. }
  • 相关阅读:
    学习笔记|ADC|NTC原理|测温程序|STC32G单片机视频开发教程（冲哥）|第十九集：ADC应用之NTC
    c语言入门---自定义类型：结构体，枚举，联合
    selenium WebDriver 中的几种等待--sleep(),implicitly_wait(),WebDriverWait()
    mybatis03与spring的集成
    Linux安装confluence
    企业快速构建可落地的IT服务管理体系的五大关键点
    哈工大李治军老师操作系统笔记【8】：用户级线程（Learning OS Concepts By Coding Them !）
    Ms08067安全实验室成功实施多家业务系统渗透测试项目
    uni-app （通过HBuilderX 和 VS Code 开发）详细连接过程教学。
    asp毕业设计——基于asp+access的在线人才招聘网设计与实现（毕业论文+程序源码）——人才招聘网
  • 原文地址：https://blog.csdn.net/Zevalin/article/details/136221486