C++ STL

于 2024-04-18 15:12:29 发布
阅读量666 收藏 20
点赞数 15
分类专栏： 编程语言 文章标签： c++ 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/a152419/article/details/137911239
版权

0. 目录

1. STL 是什么

​编辑 2. string 容器

2.1. string基本概念

2.2. string 构造函数

2.3. srting赋值操作

2.4. string字符串拼接

2.5. string查找和替换

2.6. string字符串比较

2.7. string字符存取

2.8. string插入和删除

2.9. string子串

3. vector容器

3.1. vector基本概念

3.2. vector 构造函数

3.3. vector赋值操作

3.4. vector容量和大小

3.5. vector插入和删除

3.6. vector 数据存取

3.7. vector互换容器

3.8. vector 预留空间

4. deque容器

4.1. deque 容器基本概念

4.2. deque构造函数

4.3. deque赋值操作

4.4. deque大小操作

4.5. deque 插入和删除

4.6. deque 数据存取

4.7. deque 排序

4.8 案例-评委打分

5. stack容器

5.1. stack 基本概念

5.2. stack 常用接口 

 6. queue 容器

6.1. queue 基本概念

 6.2. queue 常用接口

 7. list 容器

7.1. list基本概念

7.2. lsit构造函数

7.3. list 赋值和交换

7.4. list 大小操作

7.5. list 插入和删除

7.6. list 数据存取

7.7. 反转和排序

7.8. 排序案例

8. set/multiset 容器

8.1. set基本概念

8.2. set构造和赋值

8.3. set大小和交换

8.4. set插入和删除

8.5. set查找和统计

8.6. set和multiset区别

8.7. pair对组创建

8.8. set容器排序

8.9.multiset 实现多重优先级队列

9. map/multimap 容器

9.1. map基本概念

9.2. map构造和赋值

9.3. map大小和交换

9.4. map插入和删除

9.5. map查找和统计

9.6. map容器排序

9.7. multimap 应用

1. STL 是什么

        C++ STL 是 C++ 标准库的一部分，提供了一组通用的模板类和函数，用于实现常见的数据结构和算法。STL 提供了一种高效、灵活和标准化的方法来处理数据。

STL 主要由以下几部分组成：

  1. 容器（Containers）：容器是用于存储数据的类模板，提供了不同类型的数据结构，包括数组、链表、向量、队列、堆栈、集合、映射等。常见的容器包括 vector、list、deque、queue、stack、set、map 等。

  2. 迭代器（Iterators）：迭代器是用于遍历容器中元素的对象，允许程序员以一种统一的方式访问容器中的元素。迭代器提供了对容器元素的遍历、访问和修改功能。

  3. 算法（Algorithms）：算法是用于处理容器中数据的函数模板，提供了一系列常见的操作，包括查找、排序、合并、拷贝、删除等。STL 中的算法函数可以与各种容器类型一起使用，使得代码更加通用和可重用。

  4. 函数对象（Function Objects）：函数对象是可调用对象，可以像函数一样被调用，但可以保存状态。STL 中的函数对象包括一系列用于比较、排序和转换等操作的标准函数对象，同时也允许用户自定义函数对象。

 2. string 容器

2.1. string基本概念

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

string和char*区别：

1. char *是一个指针

2. string是一个类，类内部封装了char*，管理这个字符串，是一个char*型的容器。

特点：

string类内部封装了很多成员方法。

例如：查找，拷贝，删除替换等操作，string分配的内存，不用担心内存取值越界等问题。

2.2. string 构造函数

构造函数原型：

string(); //创建一个空的字符串，如：string str；

string(const char* s); //使用字符串s初始化

string(const string& str); //使用一个string对象初始化另一个string对象

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

#include <string>
//string构造
void test01()
{
	string s1; //创建空字符串，调用无参构造函数
	cout << "str1 = " << s1 << endl;

	const char* str = "hello world";
	string s2(str); //把c_string转换成了string

	cout << "str2 = " << s2 << endl;

	string s3(s2); //调用拷贝构造函数
	cout << "str3 = " << s3 << endl;

	string s4(10, 'a');
	cout << "str3 = " << s3 << endl;
}

int main() {

	test01();

	system("pause");

	return 0;
}

2.3. srting赋值操作

功能描述：

给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赋给当前字符串
//赋值
void test01()
{
	string str1;
	str1 = "hello world";
	cout << "str1 = " << str1 << endl;

	string str2;
	str2 = str1;
	cout << "str2 = " << str2 << endl;

	string str3;
	str3 = 'a';
	cout << "str3 = " << str3 << endl;

	string str4;
	str4.assign("hello c++");
	cout << "str4 = " << str4 << endl;

	string str5;
	str5.assign("hello c++",5);
	cout << "str5 = " << str5 << endl;


	string str6;
	str6.assign(str5);
	cout << "str6 = " << str6 << endl;

	string str7;
	str7.assign(5, 'x');
	cout << "str7 = " << str7 << endl;
}

int main() {

	test01();

	system("pause");

	return 0;
}

2.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个字符连接到字符串结尾
void test01()
{
	string str1 = "我";

	str1 += "爱玩游戏";

	cout << "str1 = " << str1 << endl;
	
	str1 += ':';

	cout << "str1 = " << str1 << endl;

	string str2 = "LOL DNF";

	str1 += str2;

	cout << "str1 = " << str1 << endl;

	string str3 = "I";
	str3.append(" love ");
	str3.append("game abcde", 4);
	//str3.append(str2);
	str3.append(str2, 4, 3); // 从下标4位置开始 ，截取3个字符，拼接到字符串末尾
	cout << "str3 = " << str3 << endl;
}
int main() {
	test01();
	system("pause");

	return 0;
}

2.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
//查找和替换
void test01()
{
    //查找
    string str1 = "abcdefgde";
    
    int pos = str1.find("de");
    
    if (pos == -1)
    {
        cout << "未找到" << endl;
    }
    else
    {
        cout << "pos = " << pos << endl;
    }
    pos = str1.rfind("de");
    cout << "pos = " << pos << endl;    
}

void test02()
{
    //替换
    string str1 = "abcdefgde";
    str1.replace(1, 3, "1111");
    
    cout << "str1 = " << str1 << endl;
}

int main() {  
    //test01();
    //test02();   
    system("pause");
    
    return 0;
}

总结：

  • find查找是从左往后，rfind从右往左
  • find找到字符串后返回查找的第一个字符位置，找不到返回-1
  • replace在替换时，要指定从哪个位置起，多少个字符，替换成什么样的字符串

2.6. string字符串比较

比较方式：
● 字符串比较是按字符的ASCII码进行对比
= 返回   0

> 返回 1

< 返回 -1

函数原型：

  • int compare(const string &s) const;  //与字符串s比较
  • int compare(const char *s) const;      //与字符串s比较
//字符串比较
void test01()
{
	string s1 = "hello";
	string s2 = "aello";

	int ret = s1.compare(s2);

	if (ret == 0) {
		cout << "s1 等于 s2" << endl;
	}
	else if (ret > 0)
	{
		cout << "s1 大于 s2" << endl;
	}
	else
	{
		cout << "s1 小于 s2" << endl;
	}
}

int main() {
	test01();
	system("pause");

	return 0;
}

2.7. string字符存取

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

  • char& operator[](int n);     //通过[]方式取字符
  • char& at(int n);                    //通过at方法获取字符
void test01()
{
	string str = "hello world";

	for (int i = 0; i < str.size(); i++)
	{
		cout << str[i] << " ";
	}
	cout << endl;

	for (int i = 0; i < str.size(); i++)
	{
		cout << str.at(i) << " ";
	}
	cout << endl;

	//字符修改
	str[0] = 'x';
	str.at(1) = 'x';
	cout << str << endl;
}

int main() {
	test01();
	system("pause");

	return 0;
}

2.8. string插入和删除

功能描述：

  • 对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个字符
//字符串插入和删除
void test01()
{
	string str = "hello";
	str.insert(1, "111");
	cout << str << endl;

	str.erase(1, 3);  //从1号位置开始3个字符
	cout << str << endl;
}

int main() {
	test01();
	system("pause");

	return 0;
}

总结：插入和删除的起始下标都是从0开始

2.9. string子串

功能描述：

  • 从字符串中获取想要的字串

函数原型：

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

	string str = "abcdefg";
	string subStr = str.substr(1, 3);
	cout << "subStr = " << subStr << endl;

	string email = "hello@sina.com";
	int pos = email.find("@");
	string username = email.substr(0, pos);
	cout << "username: " << username << endl;

}

int main() {
	test01();
	system("pause");

	return 0;
}

3. vector容器

3.1. vector基本概念

功能：

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

vector 与不同数组区别：

  • 不同之处在于数组是静态空间，而vector可以动态拓展。

动态拓展：

  • 并不是在原空间之后续接新空间，而是找更大的内存空间，将原数据拷贝到新空间，释放原空间。

  • vector 容器的迭代器是支持随机访问的迭代器

3.2. vector 构造函数

功能描述：

  • 创建vector容器

函数原型：

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

void printVector(vector<int>& v) {

	for (vector<int>::iterator it = v.begin(); it != v.end(); it++) {
		cout << *it << " ";
	}
	cout << endl;
}

void test01()
{
	vector<int> v1; //无参构造
	for (int i = 0; i < 10; i++)
	{
		v1.push_back(i);
	}
	printVector(v1);

	vector<int> v2(v1.begin(), v1.end());
	printVector(v2);

	vector<int> v3(10, 100);
	printVector(v3);
	
	vector<int> v4(v3);
	printVector(v4);
}

int main() {
	test01();
	system("pause");

	return 0;
}

3.3. vector赋值操作

功能描述：

  • 给vector容器进行赋值

函数原型：

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

void printVector(vector<int>& v) {

	for (vector<int>::iterator it = v.begin(); it != v.end(); it++) {
		cout << *it << " ";
	}
	cout << endl;
}

//赋值操作
void test01()
{
	vector<int> v1; //无参构造
	for (int i = 0; i < 10; i++)
	{
		v1.push_back(i);
	}
	printVector(v1);

	vector<int>v2;
	v2 = v1;
	printVector(v2);

	vector<int>v3;
	v3.assign(v1.begin(), v1.end());
	printVector(v3);

	vector<int>v4;
	v4.assign(10, 100);
	printVector(v4);
}

int main() {
	test01();
	system("pause");

	return 0;
}

3.4. vector容量和大小

功能描述：

  • 对vector 容器的容量大小操作

函数原型：

  • empty();                            //判断容器是否为空
  • capacity();                      //容器的容量
  • size();                              //返回容器中元素的个数
  • resize(int num);         //重新指定容器的长度为num，若容器变长，则以默认值填充新位置。
         //如果容器变短，则末尾超出容器长度的元素被删除。
  • resize(int num, elem);   //重新指定容器的长度为num，若容器变长，则以elem值填充新位置。
                  //如果容器变短，则末尾超出容器长度的元素被删除
#include <vector>

void printVector(vector<int>& v) {

	for (vector<int>::iterator it = v.begin(); it != v.end(); it++) {
		cout << *it << " ";
	}
	cout << endl;
}

void test01()
{
	vector<int> v1;
	for (int i = 0; i < 10; i++)
	{
		v1.push_back(i);
	}
	printVector(v1);
	if (v1.empty())
	{
		cout << "v1为空" << endl;
	}
	else
	{
		cout << "v1不为空" << endl;
		cout << "v1的容量 = " << v1.capacity() << endl;
		cout << "v1的大小 = " << v1.size() << endl;
	}

	//resize 重新指定大小 ，若指定的更大，默认用0填充新位置，可以利用重载版本替换默认填充
	v1.resize(15,10);
	printVector(v1);

	//resize 重新指定大小 ，若指定的更小，超出部分元素被删除
	v1.resize(5);
	printVector(v1);
}

int main() {
	test01();
	system("pause");

	return 0;
}

总结：

  • 判断是否为空  --- empty
  • 返回元素个数  --- size
  • 返回容器容量  --- capacity
  • 重新指定大小  ---  resize

3.5. vector插入和删除

功能描述：

  • 对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();                                                        //删除容器中所有元素
#include <vector>

void printVector(vector<int>& v) {

	for (vector<int>::iterator it = v.begin(); it != v.end(); it++) {
		cout << *it << " ";
	}
	cout << endl;
}

//插入和删除
void test01()
{
	vector<int> v1;
	//尾插
	v1.push_back(10);
	v1.push_back(20);
	v1.push_back(30);
	v1.push_back(40);
	v1.push_back(50);
	printVector(v1);
	//尾删
	v1.pop_back();
	printVector(v1);
	//插入
	v1.insert(v1.begin(), 100);
	printVector(v1);

	v1.insert(v1.begin(), 2, 1000);
	printVector(v1);

	//删除
	v1.erase(v1.begin());
	printVector(v1);

	//清空
	v1.erase(v1.begin(), v1.end());
	v1.clear();
	printVector(v1);
}

int main() {
	test01();
	system("pause");

	return 0;
}

总结：

  • 尾插  --- push_back
  • 尾删  --- pop_back
  • 插入  --- insert    (位置迭代器)
  • 删除  --- erase  （位置迭代器）
  • 清空  ---  clear

3.6. vector 数据存取

功能描述：

  • 对vector中的数据的存取操作

函数原型：

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

void test01()
{
	vector<int>v1;
	for (int i = 0; i < 10; i++)
	{
		v1.push_back(i);
	}

	for (int i = 0; i < v1.size(); i++)
	{
		cout << v1[i] << " ";
	}
	cout << endl;

	for (int i = 0; i < v1.size(); i++)
	{
		cout << v1.at(i) << " ";
	}
	cout << endl;

	cout << "v1的第一个元素为： " << v1.front() << endl;
	cout << "v1的最后一个元素为： " << v1.back() << endl;
}

int main() {
	test01();
	system("pause");

	return 0;
}

总结：

  • 除了用迭代器获取vector容器中元素，[ ]和at也可以
  • front返回容器第一个元素
  • back返回容器最后一个元素

3.7. vector互换容器

功能描述：

  • 实现两个容器内元素进行互换

函数原型：

  • swap(vec);  // 将vec与本身的元素互换
#include <vector>

void printVector(vector<int>& v) {

	for (vector<int>::iterator it = v.begin(); it != v.end(); it++) {
		cout << *it << " ";
	}
	cout << endl;
}

void test01()
{
	vector<int>v1;
	for (int i = 0; i < 10; i++)
	{
		v1.push_back(i);
	}
	printVector(v1);

	vector<int>v2;
	for (int i = 10; i > 0; i--)
	{
		v2.push_back(i);
	}
	printVector(v2);

	//互换容器
	cout << "互换后" << endl;
	v1.swap(v2);
	printVector(v1);
	printVector(v2);
}

void test02()
{
	vector<int> v;
	for (int i = 0; i < 100000; i++) {
		v.push_back(i);
	}

	cout << "v的容量为：" << v.capacity() << endl;
	cout << "v的大小为：" << v.size() << endl;

	v.resize(3);

	cout << "v的容量为：" << v.capacity() << endl;
	cout << "v的大小为：" << v.size() << endl;

	//收缩内存
	vector<int>(v).swap(v); //匿名对象

	cout << "v的容量为：" << v.capacity() << endl;
	cout << "v的大小为：" << v.size() << endl;
}

int main() {
	test01();
	test02();
	system("pause");

	return 0;
}

3.8. vector 预留空间

功能描述：

        减少vector在动态扩展容量时的扩展次数。

函数原型：

  • reserve(int len);//容器预留len个元素长度，预留位置不初始化，元素不可访问。
#include <vector>

void test01()
{
	vector<int> v;

	//预留空间
	v.reserve(100000);

	int num = 0;
	int* p = NULL;
	for (int i = 0; i < 100000; i++) {
		v.push_back(i);
		if (p != &v[0]) {
			p = &v[0];
			num++;
		}
	}
	cout << "num:" << num << endl;
}

int main() {
	test01(); 
	system("pause");

	return 0;
}

总结：如果数据量较大，可以一开始使用reserve预留空间

4. deque容器

4.1. deque 容器基本概念

功能：

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

deque与vector区别：

  • vector对于头部的插入删除效率低，数据量越大，效率越低
  • deque相对而言，对头部的插入删除速度会比vector快
  • vector访问元素时的速度会比deque快,这和两者内部实现有关

deque内部工作原理:

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

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

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

4.2. deque构造函数

功能描述：

  • deque容器构造

函数原型：

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

void printDeque(const deque<int>& d) 
{
	for (deque<int>::const_iterator it = d.begin(); it != d.end(); it++) {
		cout << *it << " ";

	}
	cout << endl;
}
//deque构造
void test01() {

	deque<int> d1; //无参构造函数
	for (int i = 0; i < 10; i++)
	{
		d1.push_back(i);
	}
	printDeque(d1);
	deque<int> d2(d1.begin(),d1.end());
	printDeque(d2);

	deque<int>d3(10,100);
	printDeque(d3);

	deque<int>d4 = d3;
	printDeque(d4);
}

int main() {
	test01();
	system("pause");

	return 0;
}

4.3. deque赋值操作

功能描述：

  • 给deque容器进行赋值

函数原型：

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

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);

	deque<int>d2;
	d2 = d1;
	printDeque(d2);

	deque<int>d3;
	d3.assign(d1.begin(), d1.end());
	printDeque(d3);

	deque<int>d4;
	d4.assign(10, 100);
	printDeque(d4);
}

int main() {
	test01();
	system("pause");

	return 0;
}

4.4. deque大小操作

功能描述：

  • 对deque容器的大小进行操作

函数原型：

  • deque.empty();                       //判断容器是否为空
  • deque.size();                         //返回容器中元素的个数
  • deque.resize(num);                //重新指定容器的长度为num,若容器变长，则以默认值填充新位置。
                                //如果容器变短，则末尾超出容器长度的元素被删除。
  • deque.resize(num, elem);     //重新指定容器的长度为num,若容器变长，则以elem值填充新位置。
                                                        //如果容器变短，则末尾超出容器长度的元素被删除。
#include <deque>

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);

	//判断容器是否为空
	if (d1.empty()) {
		cout << "d1为空!" << endl;
	}
	else {
		cout << "d1不为空!" << endl;
		//统计大小
		cout << "d1的大小为：" << d1.size() << endl;
	}

	//重新指定大小
	d1.resize(15, 1);
	printDeque(d1);

	d1.resize(5);
	printDeque(d1);
}

int main() {
	test01();
	system("pause");

	return 0;
}

总结：

  • deque没有容量的概念
  • 判断是否为空   --- empty
  • 返回元素个数   --- size
  • 重新指定个数   --- resize

4.5. 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 <deque>

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> d;
	//尾插
	d.push_back(10);
	d.push_back(20);
	//头插
	d.push_front(100);
	d.push_front(200);

	printDeque(d);

	//尾删
	d.pop_back();
	//头删
	d.pop_front();
	printDeque(d);
}

//插入
void test02()
{
	deque<int> d;
	d.push_back(10);
	d.push_back(20);
	d.push_front(100);
	d.push_front(200);
	printDeque(d);

	d.insert(d.begin(), 1000);
	printDeque(d);

	d.insert(d.begin(), 2,10000);
	printDeque(d);

	deque<int>d2;
	d2.push_back(1);
	d2.push_back(2);
	d2.push_back(3);

	d.insert(d.begin(), d2.begin(), d2.end());
	printDeque(d);

}

//删除
void test03()
{
	deque<int> d;
	d.push_back(10);
	d.push_back(20);
	d.push_front(100);
	d.push_front(200);
	printDeque(d);

	d.erase(d.begin());
	printDeque(d);

	d.erase(d.begin(), d.end());
	d.clear();
	printDeque(d);
}

int main() {
	//test01();
	//test02();
    test03();  
	system("pause");

	return 0;
}

总结：

  • 插入和删除提供的位置是迭代器！
  • 尾插   ---  push_back
  • 尾删   ---  pop_back
  • 头插   ---  push_front
  • 头删   ---  pop_front

4.6. deque 数据存取

功能描述：

  • 对deque 中的数据的存取操作

函数原型：

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

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> d;
	d.push_back(10);
	d.push_back(20);
	d.push_front(100);
	d.push_front(200);

	for (int i = 0; i < d.size(); i++) {
		cout << d[i] << " ";
	}
	cout << endl;

	for (int i = 0; i < d.size(); i++) {
		cout << d.at(i) << " ";
	}
	cout << endl;
	cout << "front:" << d.front() << endl;
	cout << "back:" << d.back() << endl;
}

int main() {
	test01();
	system("pause");

	return 0;
}

总结：

  • 除了用迭代器获取deque容器中元素，[ ]和at也可以
  • front返回容器第一个元素
  • back返回容器最后一个元素

4.7. deque 排序

功能描述：

  • 利用算法实现对deque容器进行排序

算法：

  • sort(iterator beg, iterator end)  //对beg和end区间内元素进行排序
#include <deque>
#include <algorithm>

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> d;
	d.push_back(10);
	d.push_back(20);
	d.push_front(100);
	d.push_front(200);

	printDeque(d);
	sort(d.begin(), d.end());
	printDeque(d);
}

int main() {
	test01();
	system("pause");

	return 0;
}

4.8 案例-评委打分

案例描述：

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

实现步骤：

  1. 创建五名选手，放到vector中

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

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

  4. deque容器遍历一遍，累加总分

  5. 获取平均分

//选手类
class Person
{
public:
	Person(string name, int score)
	{
		this->m_Name = name;
		this->m_Score = score;
	}

	string m_Name; //姓名
	int m_Score;  //平均分
};

void createPerson(vector<Person>&v)
{
	string nameSeed = "ABCDE";
	for (int i = 0; i < 5; i++)
	{
		string name = "选手";
		name += nameSeed[i];

		int score = 0;

		Person p(name, score);

		//将创建的person对象 放入到容器中
		v.push_back(p);
	}
}

//打分
void setScore(vector<Person>&v)
{
	for (vector<Person>::iterator it = v.begin(); it != v.end(); it++)
	{
		//将评委的分数 放入到deque容器中
		deque<int>d;
		for (int i = 0; i < 10; i++)
		{
			int score = rand() % 41 + 60;  // 60 ~ 100
			d.push_back(score);
		}

		//cout << "选手： " << it->m_Name << " 打分： " << endl;
		//for (deque<int>::iterator dit = d.begin(); dit != d.end(); dit++)
		//{
		//	cout << *dit << " ";
		//}
		//cout << endl;

		//排序
		sort(d.begin(), d.end());

		//去除最高和最低分
		d.pop_back();
		d.pop_front();

		//取平均分
		int sum = 0;
		for (deque<int>::iterator dit = d.begin(); dit != d.end(); dit++)
		{
			sum += *dit; //累加每个评委的分数
		}

		int avg = sum / d.size();

		//将平均分 赋值给选手身上
		it->m_Score = avg;
	}

}

void showScore(vector<Person>&v)
{
	for (vector<Person>::iterator it = v.begin(); it != v.end(); it++)
	{
		cout << "姓名： " << it->m_Name << " 平均分： " << it->m_Score << endl;
	}
}

int main() {

	//随机数种子
	srand((unsigned int)time(NULL));

	//1、创建5名选手
	vector<Person>v;  //存放选手容器
	createPerson(v);

	//测试
	//for (vector<Person>::iterator it = v.begin(); it != v.end(); it++)
	//{
	//	cout << "姓名： " << (*it).m_Name << " 分数： " << (*it).m_Score << endl;
	//}

	//2、给5名选手打分
	setScore(v);

	//3、显示最后得分
	showScore(v);

	system("pause");

	return 0;
}

5. stack容器

5.1. stack 基本概念

概念：stack是一种先进后出(First In Last Out,FILO)的数据结构，它只有一个出口

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

栈中进入数据称为 --- 入栈 push

栈中弹出数据称为 --- 出栈 pop

5.2. stack 常用接口 

功能描述：栈容器常用的对外接口

构造函数：

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

赋值操作：

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

数据存取：

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

大小操作：

  • empty();            //判断堆栈是否为空
  • size();              //返回栈的大小
#include <stack>

//栈容器常用接口
void test01()
{
	//创建栈容器 栈容器必须符合先进后出
	stack<int> s;

	//向栈中添加元素，叫做 压栈 入栈
	s.push(10);
	s.push(20);
	s.push(30);

	while (!s.empty()) {
		//输出栈顶元素
		cout << "栈顶元素为： " << s.top() << endl;
		//弹出栈顶元素
		s.pop();
	}
	cout << "栈的大小为：" << s.size() << endl;

}

int main() {

	test01();

	system("pause");

	return 0;
}

总结：

  • 入栈   --- push
  • 出栈   --- pop
  • 返回栈顶   --- top
  • 判断栈是否为空   --- empty
  • 返回栈大小   --- size

 6. queue 容器

6.1. queue 基本概念

概念：Queue是一种先进先出(First In First Out,FIFO)的数据结构，它有两个出口

队列容器允许从一端新增元素，从另一端移除元素

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

队列中进数据称为 --- 入队 push

队列中出数据称为 --- 出队 pop

 6.2. queue 常用接口

功能描述：栈容器常用的对外接口

构造函数：

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

赋值操作：

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

数据存取：

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

大小操作：

  • empty();            //判断堆栈是否为空
  • size();              //返回栈的大小 
#include <queue>
#include <string>
class Person
{
public:
	Person(string name, int age)
	{
		this->m_Name = name;
		this->m_Age = age;
	}

	string m_Name;
	int m_Age;
};

void test01() {

	//创建队列
	queue<Person> q;

	//准备数据
	Person p1("唐僧", 30);
	Person p2("孙悟空", 1000);
	Person p3("猪八戒", 900);
	Person p4("沙僧", 800);

	//向队列中添加元素  入队操作
	q.push(p1);
	q.push(p2);
	q.push(p3);
	q.push(p4);

	//队列不提供迭代器，更不支持随机访问	
	while (!q.empty()) {
		//输出队头元素
		cout << "队头元素-- 姓名： " << q.front().m_Name 
              << " 年龄： "<< q.front().m_Age << endl;
        
		cout << "队尾元素-- 姓名： " << q.back().m_Name  
              << " 年龄： " << q.back().m_Age << endl;
        
		cout << endl;
		//弹出队头元素
		q.pop();
	}

	cout << "队列大小为：" << q.size() << endl;
}

int main() {
	test01();
	system("pause");

	return 0;
}

 7. list 容器

7.1. list基本概念

功能：将数据进行链式存储

链表（list）是一种物理存储单元上非连续的存储结构，数据元素的逻辑顺序是通过链表中的指针链接实现的

链表的组成：链表由一系列结点组成

结点的组成：一个是存储数据元素的数据域，另一个是存储下一个结点地址的指针域

STL中的链表是一个双向循环链表

由于链表的存储方式并不是连续的内存空间，因此链表list中的迭代器只支持前移和后移，属于双向迭代器

list的优点：

  • 采用动态存储分配，不会造成内存浪费和溢出
  • 链表执行插入和删除操作十分方便，修改指针即可，不需要移动大量元素

list的缺点：

  • 链表灵活，但是空间(指针域) 和 时间（遍历）额外耗费较大

List有一个重要的性质，插入操作和删除操作都不会造成原有list迭代器的失效，这在vector是不成立的。

总结：STL中List和vector是两个最常被使用的容器，各有优缺点

7.2. lsit构造函数

功能描述：

  • 创建list容器

函数原型：

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

void printList(const list<int>& L) {

	for (list<int>::const_iterator it = L.begin(); it != L.end(); it++) {
		cout << *it << " ";
	}
	cout << endl;
}

void test01()
{
	list<int>L1;
	L1.push_back(10);
	L1.push_back(20);
	L1.push_back(30);
	L1.push_back(40);

	printList(L1);

	list<int>L2(L1.begin(),L1.end());
	printList(L2);

	list<int>L3(L2);
	printList(L3);

	list<int>L4(10, 1000);
	printList(L4);
}

int main() {
	test01();
	system("pause");

	return 0;
}

7.3. list 赋值和交换

功能描述：

  • 给list容器进行赋值，以及交换list容器

函数原型：

  • assign(beg, end);            //将[beg, end)区间中的数据拷贝赋值给本身。
  • assign(n, elem);              //将n个elem拷贝赋值给本身。
  • list& operator=(const list &lst);         //重载等号操作符
  • swap(lst);                         //将lst与本身的元素互换。
#include <list>

void printList(const list<int>& L) {

	for (list<int>::const_iterator it = L.begin(); it != L.end(); it++) {
		cout << *it << " ";
	}
	cout << endl;
}

//赋值和交换
void test01()
{
	list<int>L1;
	L1.push_back(10);
	L1.push_back(20);
	L1.push_back(30);
	L1.push_back(40);
	printList(L1);

	//赋值
	list<int>L2;
	L2 = L1;
	printList(L2);

	list<int>L3;
	L3.assign(L2.begin(), L2.end());
	printList(L3);

	list<int>L4;
	L4.assign(10, 100);
	printList(L4);

}

//交换
void test02()
{

	list<int>L1;
	L1.push_back(10);
	L1.push_back(20);
	L1.push_back(30);
	L1.push_back(40);

	list<int>L2;
	L2.assign(10, 100);

	cout << "交换前： " << endl;
	printList(L1);
	printList(L2);

	cout << endl;

	L1.swap(L2);

	cout << "交换后： " << endl;
	printList(L1);
	printList(L2);

}

int main() {
	//test01();
	test02();
	system("pause");

	return 0;
}

7.4. list 大小操作

功能描述：

  • 对list容器的大小进行操作

函数原型：

  • size();                             //返回容器中元素的个数
  • empty();                           //判断容器是否为空
  • resize(num);                   //重新指定容器的长度为num，若容器变长，则以默认值填充新位置。
        //如果容器变短，则末尾超出容器长度的元素被删除。
  • resize(num, elem);       //重新指定容器的长度为num，若容器变长，则以elem值填充新位置。

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

#include <list>

void printList(const list<int>& L) {

	for (list<int>::const_iterator it = L.begin(); it != L.end(); it++) {
		cout << *it << " ";
	}
	cout << endl;
}

//大小操作
void test01()
{
	list<int>L1;
	L1.push_back(10);
	L1.push_back(20);
	L1.push_back(30);
	L1.push_back(40);

	if (L1.empty())
	{
		cout << "L1为空" << endl;
	}
	else
	{
		cout << "L1不为空" << endl;
		cout << "L1的大小为： " << L1.size() << endl;
	}

	//重新指定大小
	L1.resize(10);
	printList(L1);

	L1.resize(2);
	printList(L1);
}

int main() {
	test01();
	system("pause");
	return 0;
}

总结：

  • 判断是否为空   --- empty
  • 返回元素个数   --- size
  • 重新指定个数   --- resize

7.5. list 插入和删除

功能描述：

  • 对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值匹配的元素。
#include <list>

void printList(const list<int>& L) {

	for (list<int>::const_iterator it = L.begin(); it != L.end(); it++) {
		cout << *it << " ";
	}
	cout << endl;
}

//插入和删除
void test01()
{
	list<int> L;
	//尾插
	L.push_back(10);
	L.push_back(20);
	L.push_back(30);
	//头插
	L.push_front(100);
	L.push_front(200);
	L.push_front(300);

	printList(L);

	//尾删
	L.pop_back();
	printList(L);

	//头删
	L.pop_front();
	printList(L);

	//插入
	list<int>::iterator it = L.begin();
	L.insert(++it, 1000);
	printList(L);

	//删除
	it = L.begin();
	L.erase(++it);
	printList(L);

	//移除
	L.push_back(10000);
	L.push_back(10000);
	L.push_back(10000);
	printList(L);
	L.remove(10000);
	printList(L);
    
    //清空
	L.clear();
	printList(L);
}

int main() {
	test01();
	system("pause");

	return 0;
}

总结：

  • 尾插   --- push_back
  • 尾删   --- pop_back
  • 头插   --- push_front
  • 头删   --- pop_front
  • 插入   --- insert
  • 删除   --- erase
  • 移除   --- remove
  • 清空   --- clear

7.6. list 数据存取

功能描述：

  • 对list容器中数据进行存取

函数原型：

  • front();        //返回第一个元素。
  • back();         //返回最后一个元素。
#include <list>

//数据存取
void test01()
{
	list<int>L1;
	L1.push_back(10);
	L1.push_back(20);
	L1.push_back(30);
	L1.push_back(40);

	
	//cout << L1.at(0) << endl;//错误 不支持at访问数据
	//cout << L1[0] << endl; //错误  不支持[]方式访问数据
	cout << "第一个元素为： " << L1.front() << endl;
	cout << "最后一个元素为： " << L1.back() << endl;

	//list容器的迭代器是双向迭代器，不支持随机访问
	list<int>::iterator it = L1.begin();
	//it = it + 1;//错误，不可以跳跃访问，即使是+1
}

int main() {
	test01();
	system("pause");

	return 0;
}

总结：

  • list容器中不可以通过[]或者at方式访问数据
  • 返回第一个元素   --- front
  • 返回最后一个元素   --- back

7.7. 反转和排序

功能描述：

  • 将容器中的元素反转，以及将容器中的数据进行排序

函数原型：

  • reverse();   //反转链表
  • sort();        //链表排序
void printList(const list<int>& L) {

	for (list<int>::const_iterator it = L.begin(); it != L.end(); it++) {
		cout << *it << " ";
	}
	cout << endl;
}

bool myCompare(int val1 , int val2)
{
	return val1 > val2;
}

//反转和排序
void test01()
{
	list<int> L;
	L.push_back(90);
	L.push_back(30);
	L.push_back(20);
	L.push_back(70);
	printList(L);

	//反转容器的元素
	L.reverse();
	printList(L);

	//排序
	L.sort(); //默认的排序规则 从小到大
	printList(L);

	L.sort(myCompare); //指定规则，从大到小
	printList(L);
}

int main() {
	test01();
	system("pause");

	return 0;
}

总结：

  • 反转   --- reverse
  • 排序   --- sort （成员函数）

7.8. 排序案例

案例描述：将Person自定义数据类型进行排序，Person中属性有姓名、年龄、身高

排序规则：按照年龄进行升序，如果年龄相同按照身高进行降序

#include <list>
#include <string>
class Person {
public:
	Person(string name, int age , int height) {
		m_Name = name;
		m_Age = age;
		m_Height = height;
	}

public:
	string m_Name;  //姓名
	int m_Age;      //年龄
	int m_Height;   //身高
};


bool ComparePerson(Person& p1, Person& p2) {

	if (p1.m_Age == p2.m_Age) {
		return p1.m_Height  > p2.m_Height;
	}
	else
	{
		return  p1.m_Age < p2.m_Age;
	}

}

void test01() {

	list<Person> L;

	Person p1("刘备", 35 , 175);
	Person p2("曹操", 45 , 180);
	Person p3("孙权", 40 , 170);
	Person p4("赵云", 25 , 190);
	Person p5("张飞", 35 , 160);
	Person p6("关羽", 35 , 200);

	L.push_back(p1);
	L.push_back(p2);
	L.push_back(p3);
	L.push_back(p4);
	L.push_back(p5);
	L.push_back(p6);

	for (list<Person>::iterator it = L.begin(); it != L.end(); it++) {
		cout << "姓名： " << it->m_Name << " 年龄： " << it->m_Age 
              << " 身高： " << it->m_Height << endl;
	}

	cout << "---------------------------------" << endl;
	L.sort(ComparePerson); //排序

	for (list<Person>::iterator it = L.begin(); it != L.end(); it++) {
		cout << "姓名： " << it->m_Name << " 年龄： " << it->m_Age 
              << " 身高： " << it->m_Height << endl;
	}
}

int main() {
	test01();
	system("pause");

	return 0;
}

总结：

  • 对于自定义数据类型，必须要指定排序规则，否则编译器不知道如何进行排序
  • 高级排序只是在排序规则上再进行一次逻辑规则制定，并不复杂

8. set/multiset 容器

8.1. set基本概念

简介：

  • 所有元素都会在插入时自动被排序

本质：

  • set/multiset属于关联式容器，底层结构是用二叉树实现。

set和multiset区别：

  • set不允许容器中有重复的元素
  • multiset允许容器中有重复的元素

8.2. set构造和赋值

功能描述：创建set容器以及赋值

构造：

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

赋值：

  • set& operator=(const set &st);    //重载等号操作符
#include <set>

void printSet(set<int> & s)
{
	for (set<int>::iterator it = s.begin(); it != s.end(); it++)
	{
		cout << *it << " ";
	}
	cout << endl;
}

//构造和赋值
void test01()
{
	set<int> s1;

	s1.insert(10);
	s1.insert(30);
	s1.insert(20);
	s1.insert(40);
	printSet(s1);

	//拷贝构造
	set<int>s2(s1);
	printSet(s2);

	//赋值
	set<int>s3;
	s3 = s2;
	printSet(s3);
}

int main() {

	test01();

	system("pause");

	return 0;
}

总结：

  • set容器插入数据时用insert
  • set容器插入数据的数据会自动排序

8.3. set大小和交换

功能描述：

  • 统计set容器大小以及交换set容器

函数原型：

  • size();          //返回容器中元素的数目
  • empty();        //判断容器是否为空
  • swap(st);      //交换两个集合容器
#include <set>

void printSet(set<int> & s)
{
	for (set<int>::iterator it = s.begin(); it != s.end(); it++)
	{
		cout << *it << " ";
	}
	cout << endl;
}

//大小
void test01()
{

	set<int> s1;
	
	s1.insert(10);
	s1.insert(30);
	s1.insert(20);
	s1.insert(40);

	if (s1.empty())
	{
		cout << "s1为空" << endl;
	}
	else
	{
		cout << "s1不为空" << endl;
		cout << "s1的大小为： " << s1.size() << endl;
	}

}

//交换
void test02()
{
	set<int> s1;

	s1.insert(10);
	s1.insert(30);
	s1.insert(20);
	s1.insert(40);

	set<int> s2;

	s2.insert(100);
	s2.insert(300);
	s2.insert(200);
	s2.insert(400);

	cout << "交换前" << endl;
	printSet(s1);
	printSet(s2);
	cout << endl;

	cout << "交换后" << endl;
	s1.swap(s2);
	printSet(s1);
	printSet(s2);
}

int main() {

	//test01();

	test02();

	system("pause");

	return 0;
}

总结：

  • 统计大小   --- size
  • 判断是否为空   --- empty
  • 交换容器   --- swap

8.4. set插入和删除

功能描述：

  • set容器进行插入数据和删除数据

函数原型：

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

示例：

#include <set>

void printSet(set<int> & s)
{
	for (set<int>::iterator it = s.begin(); it != s.end(); it++)
	{
		cout << *it << " ";
	}
	cout << endl;
}

//插入和删除
void test01()
{
	set<int> s1;
	//插入
	s1.insert(10);
	s1.insert(30);
	s1.insert(20);
	s1.insert(40);
	printSet(s1);

	//删除
	s1.erase(s1.begin());
	printSet(s1);

	s1.erase(30);
	printSet(s1);

	//清空
	//s1.erase(s1.begin(), s1.end());
	s1.clear();
	printSet(s1);
}

int main() {

	test01();

	system("pause");

	return 0;
}

总结：

  • 插入   --- insert
  • 删除   --- erase
  • 清空   --- clear

8.5. set查找和统计

功能描述：

  • 对set容器进行查找数据以及统计数据

函数原型：

  • find(key);                  //查找key是否存在,若存在，返回该键的元素的迭代器；若不存在，返回set.end();
  • count(key);                //统计key的元素个数

示例：

#include <set>

//查找和统计
void test01()
{
	set<int> s1;
	//插入
	s1.insert(10);
	s1.insert(30);
	s1.insert(20);
	s1.insert(40);
	
	//查找
	set<int>::iterator pos = s1.find(30);

	if (pos != s1.end())
	{
		cout << "找到了元素 ： " << *pos << endl;
	}
	else
	{
		cout << "未找到元素" << endl;
	}

	//统计
	int num = s1.count(30);
	cout << "num = " << num << endl;
}

int main() {

	test01();

	system("pause");

	return 0;
}

总结：

  • 查找   ---  find    （返回的是迭代器）
  • 统计   ---  count  （对于set，结果为0或者1）

8.6. set和multiset区别

学习目标：

  • 掌握set和multiset的区别

区别：

  • set不可以插入重复数据，而multiset可以
  • set插入数据的同时会返回插入结果，表示插入是否成功
  • multiset不会检测数据，因此可以插入重复数据
#include <set>

//set和multiset区别
void test01()
{
	set<int> s;
	pair<set<int>::iterator, bool>  ret = s.insert(10);
	if (ret.second) {
		cout << "第一次插入成功!" << endl;
	}
	else {
		cout << "第一次插入失败!" << endl;
	}

	ret = s.insert(10);
	if (ret.second) {
		cout << "第二次插入成功!" << endl;
	}
	else {
		cout << "第二次插入失败!" << endl;
	}
    
	//multiset
	multiset<int> ms;
	ms.insert(10);
	ms.insert(10);

	for (multiset<int>::iterator it = ms.begin(); it != ms.end(); it++) {
		cout << *it << " ";
	}
	cout << endl;
}

int main() {

	test01();

	system("pause");

	return 0;
}

总结：

  • 如果不允许插入重复数据可以利用set
  • 如果需要插入重复数据利用multiset

8.7. pair对组创建

功能描述：

  • 成对出现的数据，利用对组可以返回两个数据

两种创建方式：

  • pair<type, type> p ( value1, value2 );
  • pair<type, type> p = make_pair( value1, value2 );

示例：

#include <string>

//对组创建
void test01()
{
	pair<string, int> p(string("Tom"), 20);
	cout << "姓名： " <<  p.first << " 年龄： " << p.second << endl;

	pair<string, int> p2 = make_pair("Jerry", 10);
	cout << "姓名： " << p2.first << " 年龄： " << p2.second << endl;
}

int main() {

	test01();

	system("pause");

	return 0;
}

总结：

两种方式都可以创建对组，记住一种即可

8.8. set容器排序

学习目标：

  • set容器默认排序规则为从小到大，掌握如何改变排序规则

主要技术点：

  • 利用仿函数，可以改变排序规则

示例一   set存放内置数据类型

#include <set>

class MyCompare 
{
public:
	bool operator()(int v1, int v2) {
		return v1 > v2;
	}
};
void test01() 
{    
	set<int> s1;
	s1.insert(10);
	s1.insert(40);
	s1.insert(20);
	s1.insert(30);
	s1.insert(50);

	//默认从小到大
	for (set<int>::iterator it = s1.begin(); it != s1.end(); it++) {
		cout << *it << " ";
	}
	cout << endl;

	//指定排序规则
	set<int,MyCompare> s2;
	s2.insert(10);
	s2.insert(40);
	s2.insert(20);
	s2.insert(30);
	s2.insert(50);

	for (set<int, MyCompare>::iterator it = s2.begin(); it != s2.end(); it++) {
		cout << *it << " ";
	}
	cout << endl;
}

int main() {

	test01();

	system("pause");

	return 0;
}

总结：利用仿函数可以指定set容器的排序规则

示例二 set存放自定义数据类型

#include <set>
#include <string>

class Person
{
public:
	Person(string name, int age)
	{
		this->m_Name = name;
		this->m_Age = age;
	}

	string m_Name;
	int m_Age;

};
class comparePerson
{
public:
	bool operator()(const Person& p1, const Person &p2)
	{
		//按照年龄进行排序  降序
		return p1.m_Age > p2.m_Age;
	}
};

void test01()
{
	set<Person, comparePerson> s;

	Person p1("刘备", 23);
	Person p2("关羽", 27);
	Person p3("张飞", 25);
	Person p4("赵云", 21);

	s.insert(p1);
	s.insert(p2);
	s.insert(p3);
	s.insert(p4);

	for (set<Person, comparePerson>::iterator it = s.begin(); it != s.end(); it++)
	{
		cout << "姓名： " << it->m_Name << " 年龄： " << it->m_Age << endl;
	}
}
int main() {

	test01();

	system("pause");

	return 0;
}

总结：

对于自定义数据类型，set必须指定排序规则才可以插入数据

8.9.multiset 实现多重优先级队列

#include <utility>
#include <mutex>

using namespace std;

template <typename T>
class MultiPriorityQueue{
private:
	multiset <pair<int , T>> queue;
    mutex mtx;
public:
    MultiPriorityQueue();
    ~MultiPriorityQueue();
	// 插入元素，priority 表示优先级
	void push(int priority, T value);
	//弹出优先级最高的元素
	T pop();
    bool empty();
};

template <typename T>
MultiPriorityQueue<T>::MultiPriorityQueue() {

}

template <typename T>
MultiPriorityQueue<T>::~MultiPriorityQueue() {

}

template <typename T>
void MultiPriorityQueue<T>::push(int priority, T value) {
    lock_guard<mutex> lock(mtx); // 使用 lock_guard 自动管理互斥锁的生命周期
	queue.insert(make_pair(priority, value));
}

template <typename T>
T MultiPriorityQueue<T>::pop() {
    lock_guard<mutex> lock(mtx);
    if (!queue.empty()) {
        auto it = queue.begin();
        T value = it->second;
        queue.erase(it);
        return value;
    }
    else {
        // 返回一个特定值来表示队列为空
        return T();
    }
}

template <typename T>
bool MultiPriorityQueue<T>::empty() {
    lock_guard<mutex> lock(mtx); 
    return queue.empty();
}

int MultiPQ (){
    MultiPriorityQueue<string> pq;

    pq.push(2,"lsq sl");
    pq.push(1,"zwx yt");
    pq.push(2,"skl ss");
    pq.push(3,"sdf ss");

    while (!pq.empty()) {
        cout << pq.pop() << " | ";
    }
    cout << endl;
    return 0;
}

9. map/multimap 容器

9.1. map基本概念

简介：

  • map中所有元素都是pair
  • pair中第一个元素为key（键值），起到索引作用，第二个元素为value（实值）
  • 所有元素都会根据元素的键值自动排序

本质：

  • map/multimap属于关联式容器，底层结构是用二叉树实现。

优点：

  • 可以根据key值快速找到value值

map和multimap区别：

  • map不允许容器中有重复key值元素
  • multimap允许容器中有重复key值元素

9.2. map构造和赋值

功能描述：

  • 对map容器进行构造和赋值操作

函数原型：

构造：

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

赋值：

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

示例：

#include <map>

void printMap(map<int,int>&m)
{
	for (map<int, int>::iterator it = m.begin(); it != m.end(); it++)
	{
		cout << "key = " << it->first << " value = " << it->second << endl;
	}
	cout << endl;
}

void test01()
{
	map<int,int>m; //默认构造
	m.insert(pair<int, int>(1, 10));
	m.insert(pair<int, int>(2, 20));
	m.insert(pair<int, int>(3, 30));
	printMap(m);

	map<int, int>m2(m); //拷贝构造
	printMap(m2);

	map<int, int>m3;
	m3 = m2; //赋值
	printMap(m3);
}

int main() {

	test01();

	system("pause");

	return 0;
}

总结：map中所有元素都是成对出现，插入数据时候要使用对组

9.3. map大小和交换

功能描述：

  • 统计map容器大小以及交换map容器

函数原型：

  • size();          //返回容器中元素的数目
  • empty();        //判断容器是否为空
  • swap(st);      //交换两个集合容器

示例：

#include <map>

void printMap(map<int,int>&m)
{
	for (map<int, int>::iterator it = m.begin(); it != m.end(); it++)
	{
		cout << "key = " << it->first << " value = " << it->second << endl;
	}
	cout << endl;
}

void test01()
{
	map<int, int>m;
	m.insert(pair<int, int>(1, 10));
	m.insert(pair<int, int>(2, 20));
	m.insert(pair<int, int>(3, 30));

	if (m.empty())
	{
		cout << "m为空" << endl;
	}
	else
	{
		cout << "m不为空" << endl;
		cout << "m的大小为： " << m.size() << endl;
	}
}


//交换
void test02()
{
	map<int, int>m;
	m.insert(pair<int, int>(1, 10));
	m.insert(pair<int, int>(2, 20));
	m.insert(pair<int, int>(3, 30));

	map<int, int>m2;
	m2.insert(pair<int, int>(4, 100));
	m2.insert(pair<int, int>(5, 200));
	m2.insert(pair<int, int>(6, 300));

	cout << "交换前" << endl;
	printMap(m);
	printMap(m2);

	cout << "交换后" << endl;
	m.swap(m2);
	printMap(m);
	printMap(m2);
}

int main() {

	test01();

	test02();

	system("pause");

	return 0;
}

总结：

  • 统计大小   --- size
  • 判断是否为空   --- empty
  • 交换容器   --- swap

9.4. map插入和删除

功能描述：

  • map容器进行插入数据和删除数据

函数原型：

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

示例：

#include <map>

void printMap(map<int,int>&m)
{
	for (map<int, int>::iterator it = m.begin(); it != m.end(); it++)
	{
		cout << "key = " << it->first << " value = " << it->second << endl;
	}
	cout << endl;
}

void test01()
{
	//插入
	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; 
	printMap(m);

	//删除
	m.erase(m.begin());
	printMap(m);

	m.erase(3);
	printMap(m);

	//清空
	m.erase(m.begin(),m.end());
	m.clear();
	printMap(m);
}

int main() {

	test01();

	system("pause");

	return 0;
}

总结：

  • map插入方式很多，记住其一即可
  • 插入   --- insert
  • 删除   --- erase
  • 清空   --- clear

9.5. map查找和统计

功能描述：

  • 对map容器进行查找数据以及统计数据

函数原型：

  • find(key);                  //查找key是否存在,若存在，返回该键的元素的迭代器；若不存在，返回set.end();
  • count(key);                //统计key的元素个数

示例：

#include <map>

//查找和统计
void test01()
{
	map<int, int>m; 
	m.insert(pair<int, int>(1, 10));
	m.insert(pair<int, int>(2, 20));
	m.insert(pair<int, int>(3, 30));

	//查找
	map<int, int>::iterator pos = m.find(3);

	if (pos != m.end())
	{
		cout << "找到了元素 key = " << (*pos).first << " value = " << (*pos).second << endl;
	}
	else
	{
		cout << "未找到元素" << endl;
	}

	//统计
	int num = m.count(3);
	cout << "num = " << num << endl;
}

int main() {

	test01();

	system("pause");

	return 0;
}

总结：

  • 查找   ---  find    （返回的是迭代器）
  • 统计   ---  count  （对于map，结果为0或者1）

9.6. map容器排序

学习目标：

  • map容器默认排序规则为 按照key值进行 从小到大排序，掌握如何改变排序规则

主要技术点:

  • 利用仿函数，可以改变排序规则

示例：

#include <map>

class MyCompare {
public:
	bool operator()(int v1, int v2) {
		return v1 > v2;
	}
};

void test01() 
{
	//默认从小到大排序
	//利用仿函数实现从大到小排序
	map<int, int, MyCompare> m;

	m.insert(make_pair(1, 10));
	m.insert(make_pair(2, 20));
	m.insert(make_pair(3, 30));
	m.insert(make_pair(4, 40));
	m.insert(make_pair(5, 50));

	for (map<int, int, MyCompare>::iterator it = m.begin(); it != m.end(); it++) {
		cout << "key:" << it->first << " value:" << it->second << endl;
	}
}
int main() {

	test01();

	system("pause");

	return 0;
}

总结：

  • 利用仿函数可以指定map容器的排序规则
  • 对于自定义数据类型，map必须要指定排序规则,同set容器

9.7. multimap 应用

#include <map>
using namespace std;

int MyMultiMap() {

	// 创建一个 multimap，键是学生姓名，值是该学生的课程列表
	multimap<string, string> student;
	student.insert(make_pair("Alice", "Math"));
	student.insert(make_pair("Alice", "Math"));
	student.insert(make_pair("Alice", "Math"));
	student.insert(make_pair("Alice", "Math"));
	student.insert(make_pair("Bob", "Chemistry"));
	student.insert(make_pair("Bob", "Physics"));

	cout << "Students and their courses:" << endl;
	for (auto it = student.begin(); it != student.end(); ++it) {
		if (it->first ==  "Alice") {
			cout << it->first << ": " << it->second << endl;
		}
	}
	return 0;
}
搬运代码の外卖小哥
关注
专栏目录
C++ STL教程pdf
05-10
C++ STL，全称为Standard Template Library（标准模板库），是C++编程语言中不可或缺的一部分，它为程序员提供了高效且灵活的编程工具。STL的核心概念包括泛型编程、容器、迭代器、算法和函数对象，这些组件共同构成...
万字长文：C++模板与STL【常用STL容器】
最新发布
m0_51574586的博客
01-23 1100
关注博主，随时获取C++的最新技术分享
C++-模板与容器
m0_74937538的博客
01-04 1062
几乎所有的代码都采用了模板类和模板函数的方式，这相比于传统的由函数和类组成的库来说提供了更好的代码重用的机会。array是C++11新增的容器类型，与传统数组相比更加安全，易于使用。vector向量内部是由数组实现的，比较适合进行随机的存取操作，不擅长插入删除操作。容器是用来存储数据的集合，数据元素可以是任何类型（因为是使用模板实现的）此函数的功能为创建一个长度为len类型是T，默认值为t的数组并输出。迭代器是一个特殊的指针，主要用于容器的元素读写以及遍历。第一个参数为数组默认值，第二个参数为数组的长度。
C++模板和容器的介绍
No.96
08-06 1711
模板的简介 模板是实现代码重用机制的一种工具，实质就是实现类型参数化，即把类型定义为参数。 C++提供两种模板：函数模板，类模板类模板 template <class T>//或者template<class T> class My { private: T a; T b; public: My(); My(T x1,T x2) {
C++ 容器详解
暖心~的博客
04-14 6499
顺序容器：此处的顺序不是体现在元素的值的顺序，而是指的是元素加入容器时的位置相对应的。 关联容器：顺序容器分类： 类型 特点 vector 可变大小数组 支持快速随机访 在尾部之外的位置插入或删除元素可能很慢。 deque 双端队列 支持快速随机访问 在头尾位置插入/删除速度很快 list 双向链表 只支持双向顺序访问 在list的
C++_进阶之函数模板_类模板
weixin_30895603的博客
04-15 2322
C++_进阶之函数模板_类模板 第一部分 前言 　　c++提供了函数模板(function template.)所谓函数模板，实际上是建立一个通用函数，其函数类型和形参类型不具体制定，用一个虚拟的类型来代表。这个通用函数就成为函数模板。凡是函数体相同的函数都可以用这个模板代替，不必定义多个函数，只需在模板中定义一次即可。在调用函数时系统会根据实参的类型来取代模板中的虚拟类型，从而实现不同函...
c++ STL模板
11-08
向量vector是一种随机访问的数组类型，提供了对数组元素的快速、随机访问以及在序列尾部快速、随机的插入和删除操作。它是大小可变的向量，在需要是可以改变其大小。 形式：
C++STL手册.rar
09-23
**C++ STL（Standard Template Library）手册** C++ STL 是 C++ 标准库中的一个核心部分，它提供了一组高效、可重用的容器、算法和迭代器模板类。STL 的设计思想源于泛型编程，使得程序员可以编写与数据类型无关的...
C++ STL 参考手册Cpp_STL_ReferenceManual.pdf
12-21
STL 是 C++ 标准库的一部分，不用单独安装。 C++ 对模板（Template）支持得很好，STL 就是借助模板把常用的数据结构及其算法都实现了一遍，并且做到了数据结构和算法的分离。例如，vector 的底层为顺序表（数组），...
c++ STL思维导图（自己总结）
04-30
C++ STL思维导图（自己总结） C++ STL（Standard Template Library）是C++程序设计语言的标准模板库，提供了许多有用的容器、算法和函数，帮助开发者快速构建高效的程序。本文将总结C++ STL中的主要容器和算法，...
C++ STL库应用汇总
08-24
C++ STL库应用汇总 C++ STL库是泛型程序设计最成功应用的实例，是一些常用数据结构（如链表、可变长数组、排序二叉树）和算法（如排序、查找）的模板的集合。STL 主要由 Alex Stepanov 主持开发，于 1998 年被加入...
c++ stl教程.zip
01-30
C++ STL（Standard Template Library，标准模板库）是C++编程中极其重要的一部分，它提供了一组高效、灵活且可重用的容器、迭代器、算法和函数对象，极大地简化了C++程序员处理数据结构和算法的过程。STL的核心概念...
C++ STL--数据结构与算法实现（余文溪）示例程序代码.rar
11-10
C++ STL，全称为Standard Template Library（标准模板库），是C++编程语言中的一部分，它提供了丰富的容器、迭代器、算法和函数对象等组件，极大地简化了数据结构和算法的实现。余文溪的《C++ STL--数据结构与算法...
C++ STL源码
08-07
The STL was developed on SGI MIPSproTM C++ 7.0, 7.1, 7.2, and 7.2.1. If you are using the 7.0 compiler, you must compile using either the -n32 or the -64 flag; if you are using 7.1 or later, you may ...
C++STL库函数
03-30
C++ STL（Standard Template Library，标准模板库）是C++编程语言中不可或缺的一部分，它提供了一组高效且灵活的容器、算法和迭代器，极大地提高了程序员的生产力。STL库函数是C++程序设计的核心工具，帮助开发者...
C++标准模板库（STL）和容器
weixin_30588675的博客
11-01 429
1、什么是标准模板库（STL）？ (1)C++标准模板库与C++标准库的关系 C++标准模板库其实属于C++标准库的一部分，C++标准模板库主要是定义了标准模板的定义与声明，而这些模板主要都是 类模板，我们可以调用这些模板来定义一个具体的类；与之前的自己手动创建一个函数模版或者是类模板不一样，我们使用了 STL就不用自己来创建模板了，这些模板都定义在标准模板库中，我们只需要学会怎么使用这些...
C++的标准模板库&容器
galaxyrt的博客
06-03 546
STL（Standard Template Library ,标准模板库）是一套功能强大的C++类模板，它提供了通用的类模板和模板函数，可以实现多种常用算法和数据结构，如：向量，链表，
C++ 泛型（模板与容器）
红叶谷 wsp_1138886114的博客
02-09 4821
文章目录一、泛型的基本思想： 一、泛型的基本思想： 泛型编程（Generic Programming）是一种语言机制，通过它可以实现一个标准的容器库。 像类一样，泛型也是一种抽象数据类型，但是泛型不属于面向对象，它是面向对象的补充和发展。在面向对象编程中，当算法与数据类型有关时，面向对象在对算法的抽象描述方面存在一些缺陷。 泛型在C++中的主要实现为模板函数和模板类。 通常使用普通的函数实现一个与...
C++ STL容器操作大全
C++STL操作大全 C++ STL（Standard Template Library）是C++标准库中的一个组件，提供了大量的泛型容器、算法和迭代器，帮助开发者快速构建高效、可靠的应用程序。下面是C++ STL中的一些重要知识点： 一、Vector ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值