• C++提高:03 STL- 常用容器_2


    5 stack容器

    5.1 stack 基本概念

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

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

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

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

    5.2 stack 常用接口

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

    构造函数:

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

    赋值操作:

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

    数据存取:

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

    大小操作:

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

    示例:

    #include 
    
    //栈容器常用接口
    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;
    }
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31

    总结:

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

    6 queue 容器

    6.1 queue 基本概念

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

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

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

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

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

    6.2 queue 常用接口

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

    构造函数:

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

    赋值操作:

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

    数据存取:

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

    大小操作:

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

    示例:

    #include 
    #include 
    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;
    }
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54
    • 55
    • 56
    • 57

    总结:

    • 入队 — push
    • 出队 — pop
    • 返回队头元素 — front
    • 返回队尾元素 — back
    • 判断队是否为空 — empty
    • 返回队列大小 — size

    7 list容器

    7.1 list基本概念

    **功能:**将数据进行链式存储

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

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

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

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

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

    list的优点:

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

    list的缺点:

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

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

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

    7.2 list构造函数

    功能描述:

    • 创建list容器

    函数原型:

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

    示例:

    #include 
    
    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;
    }
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38

    总结:list构造方式同其他几个STL常用容器,熟练掌握即可

    7.3 list 赋值和交换

    功能描述:

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

    函数原型:

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

    示例:

    #include 
    
    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;
    }
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54
    • 55
    • 56
    • 57
    • 58
    • 59
    • 60
    • 61
    • 62
    • 63
    • 64
    • 65
    • 66
    • 67
    • 68
    • 69
    • 70
    • 71
    • 72

    总结:list赋值和交换操作能够灵活运用即可

    7.4 list 大小操作

    功能描述:

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

    函数原型:

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

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

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

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

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

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

    示例:

    #include 
    
    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;
    }
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45

    总结:

    • 判断是否为空 — 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 
    
    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;
    }
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54
    • 55
    • 56
    • 57
    • 58
    • 59
    • 60
    • 61
    • 62
    • 63
    • 64

    总结:

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

    7.6 list 数据存取

    功能描述:

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

    函数原型:

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

    示例:

    #include 
    
    //数据存取
    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;
    }
    
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31

    总结:

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

    7.7 list 反转和排序

    功能描述:

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

    函数原型:

    • 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;
    }
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43

    总结:

    • 反转 — reverse
    • 排序 — sort (成员函数)

    7.8 排序案例

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

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

    示例:

    #include 
    #include 
    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;
    }
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54
    • 55
    • 56
    • 57
    • 58
    • 59
    • 60
    • 61
    • 62
    • 63
    • 64
    • 65
    • 66
    • 67
    • 68
    • 69

    总结:

    • 对于自定义数据类型,必须要指定排序规则,否则编译器不知道如何进行排序

    • 高级排序只是在排序规则上再进行一次逻辑规则制定,并不复杂

    8 set/ multiset 容器

    8.1 set基本概念

    简介:

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

    本质:

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

    set和multiset区别

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

    8.2 set构造和赋值

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

    构造:

    • set st; //默认构造函数:
    • set(const set &st); //拷贝构造函数

    赋值:

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

    示例:

    #include 
    
    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;
    }
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40

    总结:

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

    8.3 set大小和交换

    功能描述:

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

    函数原型:

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

    示例:

    #include 
    
    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;
    }
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54
    • 55
    • 56
    • 57
    • 58
    • 59
    • 60
    • 61
    • 62
    • 63
    • 64
    • 65
    • 66
    • 67
    • 68
    • 69
    • 70
    • 71
    • 72

    总结:

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

    8.4 set插入和删除

    功能描述:

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

    函数原型:

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

    示例:

    #include 
    
    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;
    }
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43

    总结:

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

    8.5 set查找和统计

    功能描述:

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

    函数原型:

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

    示例:

    #include 
    
    //查找和统计
    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;
    }
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37

    总结:

    • 查找 — find (返回的是迭代器)
    • 统计 — count (对于set,结果为0或者1)

    8.6 set和multiset区别

    学习目标:

    • 掌握set和multiset的区别

    区别:

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

    示例:

    #include 
    
    //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;
    }
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41

    总结:

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

    8.7 pair对组创建

    功能描述:

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

    两种创建方式:

    • pair p ( value1, value2 );
    • pair p = make_pair( value1, value2 );

    示例:

    #include 
    
    //对组创建
    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;
    }
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20

    总结:

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

    8.8 set容器排序

    学习目标:

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

    主要技术点:

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

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

    #include 
    
    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;
    }
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46

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

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

    #include 
    #include 
    
    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;
    }
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53

    总结:

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

    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 mp; //map默认构造函数:
    • map(const map &mp); //拷贝构造函数

    赋值:

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

    示例:

    #include 
    
    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;
    }
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35

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

    9.3 map大小和交换

    功能描述:

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

    函数原型:

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

    示例:

    #include 
    
    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;
    }
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54
    • 55
    • 56
    • 57
    • 58
    • 59
    • 60
    • 61
    • 62
    • 63

    总结:

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

    9.4 map插入和删除

    功能描述:

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

    函数原型:

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

    示例:

    #include 
    
    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;
    }
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46

    总结:

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

    9.5 map查找和统计

    功能描述:

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

    函数原型:

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

    示例:

    #include 
    
    //查找和统计
    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;
    }
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35

    总结:

    • 查找 — find (返回的是迭代器)
    • 统计 — count (对于map,结果为0或者1)

    9.6 map容器排序

    学习目标:

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

    主要技术点:

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

    示例:

    #include 
    
    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;
    }
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33

    总结:

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

    10 案例-员工分组

    10.1 案例描述

    • 公司今天招聘了10个员工(ABCDEFGHIJ),10名员工进入公司之后,需要指派员工在那个部门工作
    • 员工信息有: 姓名 工资组成;部门分为:策划、美术、研发
    • 随机给10名员工分配部门和工资
    • 通过multimap进行信息的插入 key(部门编号) value(员工)
    • 分部门显示员工信息

    10.2 实现步骤

    1. 创建10名员工,放到vector中
    2. 遍历vector容器,取出每个员工,进行随机分组
    3. 分组后,将员工部门编号作为key,具体员工作为value,放入到multimap容器中
    4. 分部门显示员工信息

    案例代码:

    #include
    using namespace std;
    #include 
    #include 
    #include 
    #include 
    
    /*
    - 公司今天招聘了10个员工(ABCDEFGHIJ),10名员工进入公司之后,需要指派员工在那个部门工作
    - 员工信息有: 姓名  工资组成;部门分为:策划、美术、研发
    - 随机给10名员工分配部门和工资
    - 通过multimap进行信息的插入  key(部门编号) value(员工)
    - 分部门显示员工信息
    */
    
    #define CEHUA  0
    #define MEISHU 1
    #define YANFA  2
    
    class Worker
    {
    public:
    	string m_Name;
    	int m_Salary;
    };
    
    void createWorker(vector<Worker>&v)
    {
    	string nameSeed = "ABCDEFGHIJ";
    	for (int i = 0; i < 10; i++)
    	{
    		Worker worker;
    		worker.m_Name = "员工";
    		worker.m_Name += nameSeed[i];
    
    		worker.m_Salary = rand() % 10000 + 10000; // 10000 ~ 19999
    		//将员工放入到容器中
    		v.push_back(worker);
    	}
    }
    
    //员工分组
    void setGroup(vector<Worker>&v,multimap<int,Worker>&m)
    {
    	for (vector<Worker>::iterator it = v.begin(); it != v.end(); it++)
    	{
    		//产生随机部门编号
    		int deptId = rand() % 3; // 0 1 2 
    
    		//将员工插入到分组中
    		//key部门编号,value具体员工
    		m.insert(make_pair(deptId, *it));
    	}
    }
    
    void showWorkerByGourp(multimap<int,Worker>&m)
    {
    	// 0  A  B  C   1  D  E   2  F G ...
    	cout << "策划部门:" << endl;
    
    	multimap<int,Worker>::iterator pos = m.find(CEHUA);
    	int count = m.count(CEHUA); // 统计具体人数
    	int index = 0;
    	for (; pos != m.end() && index < count; pos++ , index++)
    	{
    		cout << "姓名: " << pos->second.m_Name << " 工资: " << pos->second.m_Salary << endl;
    	}
    
    	cout << "----------------------" << endl;
    	cout << "美术部门: " << endl;
    	pos = m.find(MEISHU);
    	count = m.count(MEISHU); // 统计具体人数
    	index = 0;
    	for (; pos != m.end() && index < count; pos++, index++)
    	{
    		cout << "姓名: " << pos->second.m_Name << " 工资: " << pos->second.m_Salary << endl;
    	}
    
    	cout << "----------------------" << endl;
    	cout << "研发部门: " << endl;
    	pos = m.find(YANFA);
    	count = m.count(YANFA); // 统计具体人数
    	index = 0;
    	for (; pos != m.end() && index < count; pos++, index++)
    	{
    		cout << "姓名: " << pos->second.m_Name << " 工资: " << pos->second.m_Salary << endl;
    	}
    
    }
    
    int main() {
    
    	srand((unsigned int)time(NULL));
    
    	//1、创建员工
    	vector<Worker>vWorker;
    	createWorker(vWorker);
    
    	//2、员工分组
    	multimap<int, Worker>mWorker;
    	setGroup(vWorker, mWorker);
    
    
    	//3、分组显示员工
    	showWorkerByGourp(mWorker);
    
    	测试
    	//for (vector::iterator it = vWorker.begin(); it != vWorker.end(); it++)
    	//{
    	//	cout << "姓名: " << it->m_Name << " 工资: " << it->m_Salary << endl;
    	//}
    
    	system("pause");
    
    	return 0;
    }
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54
    • 55
    • 56
    • 57
    • 58
    • 59
    • 60
    • 61
    • 62
    • 63
    • 64
    • 65
    • 66
    • 67
    • 68
    • 69
    • 70
    • 71
    • 72
    • 73
    • 74
    • 75
    • 76
    • 77
    • 78
    • 79
    • 80
    • 81
    • 82
    • 83
    • 84
    • 85
    • 86
    • 87
    • 88
    • 89
    • 90
    • 91
    • 92
    • 93
    • 94
    • 95
    • 96
    • 97
    • 98
    • 99
    • 100
    • 101
    • 102
    • 103
    • 104
    • 105
    • 106
    • 107
    • 108
    • 109
    • 110
    • 111
    • 112
    • 113
    • 114
    • 115
    • 116

    总结:

    • 当数据以键值对形式存在,可以考虑用map 或 multimap
  • 相关阅读:
    AtCoder Beginner Contest 276 G - Count Sequences 差分
    CSS 多行文本超链接下划线动效
    JavaScript基础-简单易懂总结
    一次简单的SQL注入靶场练习
    测试到底是个啥
    有了一个产品想法,如何确定要不要做,如何一步步推进?
    java中的悲观锁和乐观锁
    AcWing 287. 积蓄程度,《算法竞赛进阶指南》
    基于springboot的(校园)二手商城网站
    有手就行10——Jenkins+SonarQube代码审查
  • 原文地址:https://blog.csdn.net/qq_44922487/article/details/133204491