C++阶段05笔记04【C++提高编程资料(queue容器、list容器、set/multiset容器、map/multimap容器)】

最新推荐文章于 2022-12-29 22:59:50 发布
最新推荐文章于 2022-12-29 22:59:50 发布
阅读量286 收藏
点赞数 1
分类专栏： C++ 文章标签： c++ queue list set map
希望对您有所帮助；知识共享，欢迎转载，转载时：请附上原文链接！
本文链接：https://blog.csdn.net/weixin_44949135/article/details/126320602
版权

C++| 匠心之作 从0到1入门学编程【视频+课件+笔记+源码】

目录

3、STL常用容器

3.6、queue容器

3.6.1、queue基本概念

3.6.2、queue常用接口

3.7、list容器

3.7.1、list基本概念

3.7.2、list构造函数

3.7.3、list赋值和交换

3.7.4、list大小操作

3.7.5、list插入和删除

3.7.6、list数据存取

3.7.7、list反转和排序

3.7.8、排序案例

3.8、set/multiset容器

3.8.1、set基本概念

3.8.2、set构造和赋值

3.8.3、set大小和交换

3.8.4、set插入和删除

3.8.5、set查找和统计

3.8.6、set和multiset区别

3.8.7、pair对组创建

3.8.8、set容器排序

3.9、map/multimap容器

3.9.1、map基本概念

3.9.2、map构造和赋值

3.9.3、map大小和交换

3.9.4、map插入和删除

3.9.5、map查找和统计

3.9.6、map容器排序

3.10、案例-员工分组

3.10.1、案例描述

3.10.2、实现步骤

3、STL常用容器

3.6、queue容器

3.6.1、queue基本概念

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

 

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

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

队列中进数据称为——入队push，队列中出数据称为——出队pop。

queue队列的基本概念

3.6.2、queue常用接口

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

构造函数：

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

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

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

数据存取：

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

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

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

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

大小操作：

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

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

示例：

#include <iostream>
#include <string>
#include <queue>//队列Queue
using namespace std;

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);
	cout << "队列大小为：" << q.size() << endl;//4

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

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

总结：

  1. 入队——push；

  2. 出队——pop；

  3. 返回队头元素——front；

  4. 返回队尾元素——back；

  5. 判断队是否为空——empty；

  6. 返回队列大小——size。

3.7、list容器

3.7.1、list基本概念

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

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

链表的组成：链表由一系列结点组成；结点的组成：一个是存储数据元素的数据域，另一个是存储下一个结点地址的指针域。

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

list容器的基本概念

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

list的优点：

  • 采用动态存储分配，不会造成内存浪费和溢出；

  • 链表执行插入和删除操作十分方便，修改指针即可，不需要移动大量元素。

list的缺点：链表灵活，但是空间(指针域)和时间(遍历)额外耗费较大。

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

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

3.7.2、list构造函数

功能描述：创建list容器。

函数原型：

  1. list<T> lst; //list采用采用模板类实现,对象的默认构造形式：

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

  3. list(n,elem); //构造函数将n个elem拷贝给本身。

  4. list(const list &lst); //拷贝构造函数。

示例：

#include <iostream>
#include <list>
using namespace std;
//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容器
    list<int> L1;//默认构造

    //添加数据
    L1.push_back(10);
    L1.push_back(20);
    L1.push_back(30);
    L1.push_back(40);

    //遍历容器
    printList(L1);//10 20 30 40

    //区间方式构造
    list<int> L2(L1.begin(), L1.end());
    printList(L2);//10 20 30 40

    //拷贝构造
    list<int> L3(L2);
    printList(L3);//10 20 30 40

    //n个elem
    list<int> L4(10, 11);
    printList(L4);//11 11 11 11 11 11 11 11 11 11
}

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

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

3.7.3、list赋值和交换

功能描述：给list容器进行赋值，以及交换list容器。

函数原型：

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

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

  3. list& operator=(const list &lst); //重载等号操作符

  4. swap(lst); //将lst与本身的元素互换。

示例：

#include <iostream>
#include <list>
using namespace std;

// 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;//operator=赋值
    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;
}

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

3.7.4、list大小操作

功能描述：对list容器的大小进行操作。

函数原型：

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

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

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

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

示例：

#include <iostream>
#include <list>
using namespace std;
//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);

    //判断容器是否为空
    if (L1.empty()) {
        cout << "L1为空！" << endl;
    } else {
        cout << "L1不为空！" << endl;
        cout << "L1的元素个数为：" << L1.size() << endl;
    }

    //重新指定大小
    //L1.resize(10);
    L1.resize(10, 10000);
    printList(L1);//10 20 30 40 10000 10000 10000 10000 10000 10000

    L1.resize(2);
    printList(L1);//10 20
}

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

总结：1.判断是否为空——empty；2.返回元素个数——size；3.重新指定个数——resize。

3.7.5、list插入和删除

功能描述：对list容器进行数据的插入和删除。

函数原型：

  1. push_back(elem);//在容器尾部加入一个元素

  2. pop_back();//删除容器中最后一个元素

  3. push_front(elem);//在容器开头插入一个元素

  4. pop_front();//从容器开头移除第一个元素

  5. insert(pos, elem);//在pos位置插elem元素的拷贝，返回新数据的位置。

  6. insert(pos, n, elem);//在pos位置插入n个elem数据，无返回值。

  7. insert(pos, beg, end);//在pos位置插入[beg, end)区间的数据，无返回值。

  8. clear();//移除容器的所有数据

  9. erase(beg, end);//删除[beg, end)区间的数据，返回下一个数据的位置。

  10. erase(pos);//删除pos位置的数据，返回下一个数据的位置。

  11. remove(elem);//删除容器中所有与elem值匹配的元素。

示例：

#include <iostream>
#include <list>
using namespace std;

//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值匹配的元素。
*/

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);//300 200 100 10 20 30

    //尾删
    L.pop_back();
    printList(L);//300 200 100 10 20

    //头删
    L.pop_front();
    printList(L);//200 100 10 20

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

    //删除
    it = L.begin();
    L.erase(++it);
    printList(L);//200 100 10 20

    //移除
    L.push_back(10000);
    L.push_back(10000);
    L.push_back(10000);
    L.push_back(10000);
    printList(L);//200 100 10 20 10000 10000 10000 10000

    L.remove(10000);
    printList(L);//200 100 10 20

    //清空
    L.clear();
    printList(L);
}

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

总结：

  1. 尾插——push_back；

  2. 尾删——pop_back；

  3. 头插——push_front；

  4. 头删——pop_front；

  5. 插入——insert；

  6. 删除——erase；

  7. 移除——remove；

  8. 清空——clear。

3.7.6、list数据存取

功能描述：对list容器中数据进行存取。

函数原型：

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

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

示例：

#include <iostream>
#include <list>
using namespace std;

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

    // L1[0]，不可以用[]访问list容器中的元素
    // L1.at(0)，不可以用at方式访问list容器中的元素
    //原因是list本质链表，不是用连续线性空间存储数据，迭代器也是不支持随机访问的

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

    //验证迭代器是不支持随机访问的
    list<int>::iterator it = L1.begin();
    it++;//支持双向
    it--;
    //it = it + 1;//不支持随机访问


    //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. list容器中不可以通过[]或者at方式访问数据；

  2. 返回第一个元素——front；返回最后一个元素——back。

3.7.7、list反转和排序

功能描述：将容器中的元素反转，以及将容器中的数据进行排序。

函数原型：

  1. reverse(); //反转链表

  2. sort(); //链表排序

示例：

#include <iostream>
#include <list>
#include <algorithm>
using namespace std;

// list容器反转和排序

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;
// }
bool myCompare(int v1, int v2) {
    //降序：就让第一个数 > 第二个数
    return v1 > v2;
}

//反转
void test01() {
    list<int> L1;
    L1.push_back(20);
    L1.push_back(10);
    L1.push_back(50);
    L1.push_back(40);
    L1.push_back(30);
    cout << "反转前：" << endl;
    printList(L1);

    //反转
    L1.reverse();//反转容器的元素
    cout << "反转后：" << endl;
    printList(L1);
}

//排序
void test02() {
    list<int> L1;
    L1.push_back(20);
    L1.push_back(10);
    L1.push_back(50);
    L1.push_back(40);
    L1.push_back(30);

    //排序
    cout << "排序前：" << endl;
    printList(L1);

    //所有不支持随机访问迭代器的容器，不可以用标准算法
    //不支持随机访问迭代器的容器，内部会提供对应一些算法
    //sort(L1.begin(), L1.end());

    L1.sort(); //默认排序规则：从小到大升序
    cout << "排序后：" << endl;
    printList(L1);

    L1.sort(myCompare);
    printList(L1);
}

//反转和排序
void test03() {
	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();
    test02();
    test03();
    system("pause");
    return 0;
}

总结：反转——reverse；排序——sort (成员函数)。

3.7.8、排序案例

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

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

示例：

#include <iostream>
#include <string>
#include <list>
using namespace std;

//list容器-排序案例：对于自定义数据类型做排序
//按照年龄进行升序，如果年龄相同按照身高进行降序

class Person {
	public:
		Person(string name, int age, int height) {
			this->m_Name = name;
			this->m_Age = age;
			this->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;
	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.8、set/multiset容器

3.8.1、set基本概念

简介：所有元素都会在插入时自动被排序。

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

set和multiset区别：set不允许容器中有重复的元素；multiset允许容器中有重复的元素。

3.8.2、set构造和赋值

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

构造：

  • set<T> st; //默认构造函数：

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

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

示例：

#include <iostream>
#include <set>
using namespace std;

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

    //插入数据 只有insert方式
    s1.insert(10);
    s1.insert(40);
    s1.insert(30);
    s1.insert(20);
    s1.insert(30);

    //遍历容器
    //set容器特点：所有元素插入时候自动被排序
    //set容器不允许插入重复值
    printSet(s1);

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

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

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

总结：1.set容器插入数据时用insert；2.set容器插入数据的数据会自动排序。

3.8.3、set大小和交换

功能描述：统计set容器大小以及交换set容器。

函数原型：

  1. size(); //返回容器中元素的数目

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

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

示例：

#include <iostream>
#include <set>
using namespace std;

//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);//打印容器
    //判断是否为空
    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.统计大小——size；2.判断是否为空——empty；3.交换容器——swap。

3.8.4、set插入和删除

功能描述：set容器进行插入数据和删除数据。

函数原型：

  1. insert(elem); //在容器中插入元素。

  2. clear(); //清除所有元素

  3. erase(pos); //删除pos迭代器所指的元素，返回下一个元素的迭代器。

  4. erase(beg, end); //删除区间[beg,end)的所有元素 ，返回下一个元素的迭代器。

  5. erase(elem); //删除容器中值为elem的元素。

示例：

#include <iostream>
#include <set>
using namespace std;

//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(30);
    s1.insert(10);
    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.插入——insert；2.删除——erase；3.清空——clear。

3.8.5、set查找和统计

功能描述：对set容器进行查找数据以及统计数据。

函数原型：

  1. find(key); //查找key是否存在，若存在，返回该键的元素的迭代器；若不存在，返回set.end();

  2. count(key); //统计key的元素个数

示例：

#include <iostream>
#include <set>
using namespace std;

//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;
}

//统计
void test02() {
    //查找
    set<int> s1;

    //插入数据
    s1.insert(10);
    s1.insert(30);
    s1.insert(20);
    s1.insert(40);

    //统计30的个数
    int num = s1.count(30);
    //对于set而言，统计结果要么是0要么是1
    cout << "num = " << num << endl;
}

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

总结：1.查找——find （返回的是迭代器）；2.统计——count （对于set，结果为0或者1）。

3.8.6、set和multiset区别

学习目标：掌握set和multiset的区别。

区别：

  1. set不可以插入重复数据，而multiset可以；

  2. set插入数据的同时会返回插入结果，表示插入是否成功；

  3. multiset不会检测数据，因此可以插入重复数据。

示例：

#include <iostream>
#include <set>
using namespace std;

//set容器和multiset容器的区别
void test01() {//set和multiset区别
    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);
    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。

3.8.7、pair对组创建

功能描述：成对出现的数据，利用对组可以返回两个数据。

两种创建方式：

  1. pair<type, type> p ( value1, value2 );

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

示例：

#include <iostream>
#include <string>
using namespace std;

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

    //第二种方式
    pair<string, int> p2 = make_pair("Jerry", 30);
    cout << "姓名：" << p2.first << "，年龄：" << p2.second << endl;
}

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

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

3.8.8、set容器排序

学习目标：set容器默认排序规则为从小到大，掌握如何改变排序规则。

主要技术点：利用仿函数，可以改变排序规则。

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

#include <iostream>
#include <set>//set容器排序
using namespace std;

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(50);
    s1.insert(30);

    //默认从小到大
    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(50);
    s2.insert(30);

    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 <iostream>
#include <string>
#include <set>//set容器排序，存放自定义数据类型
using namespace std;

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对象
	Person p1("刘备", 24);
	Person p2("关羽", 28);
	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必须指定排序规则才可以插入数据。

3.9、map/multimap容器

3.9.1、map基本概念

简介：

  1. map中所有元素都是pair；

  2. pair中第一个元素为key（键值），起到索引作用，第二个元素为value（实值）；

  3. 所有元素都会根据元素的键值自动排序。

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

优点：可以根据key值快速找到value值。

map和multimap区别：1.map不允许容器中有重复key值元素；2.multimap允许容器中有重复key值元素。

3.9.2、map构造和赋值

功能描述：对map容器进行构造和赋值操作。

函数原型：

构造：

  1. map<T1, T2> mp; //map默认构造函数

  2. map(const map &mp); //拷贝构造函数

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

示例：

#include <iostream>
#include <map>
using namespace std;

//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容器
    map<int, int> m;//默认构造

    m.insert(pair<int, int>(1, 10));
    m.insert(pair<int, int>(3, 30));
    m.insert(pair<int, int>(2, 20));
    m.insert(pair<int, int>(4, 40));
    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中所有元素都是成对出现，插入数据时候要使用对组。

3.9.3、map大小和交换

功能描述：统计map容器大小以及交换map容器。

函数原型：

  1. size(); //返回容器中元素的数目

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

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

示例：

#include <iostream>
#include <map>
using namespace std;
//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;
}

总结：1.统计大小——size；2.判断是否为空——empty；3.交换容器——swap。

3.9.4、map插入和删除

功能描述：map容器进行插入数据和删除数据。

函数原型：

  1. insert(elem); //在容器中插入元素

  2. clear(); //清除所有元素

  3. erase(pos); //删除pos迭代器所指的元素，返回下一个元素的迭代器。

  4. erase(beg, end); //删除区间[beg,end)的所有元素 ，返回下一个元素的迭代器。

  5. erase(key); //删除容器中值为key的元素

示例：

#include <iostream>
#include <map>
using namespace std;

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

    //[]不建议插入，用途：可以利用key访问到value
    // cout << m[4] << endl;
    printMap(m);

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

    m.erase(3);//按照key删除
    printMap(m);

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

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

总结：1.map插入方式很多，记住其一即可；2.插入——insert；3.删除——erase；4.清空——clear。

3.9.5、map查找和统计

功能描述：对map容器进行查找数据以及统计数据。

函数原型：

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

  • count(key); //统计key的元素个数

示例：

#include <iostream>
#include <map>
using namespace std;

//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));
    m.insert(pair<int, int>(3, 40));

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

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

    //统计
    //map不允许插入重复key 元素；就count统计而言，结果要么是0要么是1
    //multimap的count统计可能大于1
    int num = m.count(3);
    cout << "num = " << num << endl;
}

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

总结：查找——find （返回的是迭代器）；统计——count （对于map，结果为0或者1）。

3.9.6、map容器排序

学习目标：map容器默认排序规则为 按照key值进行 从小到大排序，掌握如何改变排序规则。

主要技术点：利用仿函数，可以改变排序规则。

示例：

#include <iostream>
#include <map>
using namespace std;

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

//map容器-排序
void test01() {
	map<int, int, MyCompare> m;
	//默认从小到大排序，利用仿函数实现从大到小排序
	m.insert(make_pair(1, 10));
	m.insert(make_pair(2, 20));
	m.insert(make_pair(5, 50));
	m.insert(make_pair(3, 30));
	m.insert(make_pair(4, 40));
	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容器。

3.10、案例-员工分组

3.10.1、案例描述

  1. 公司今天招聘了10个员工（ABCDEFGHIJ），10名员工进入公司之后，需要指派员工在那个部门工作；

  2. 员工信息有: 姓名 工资组成；部门分为：策划、美术、研发；

  3. 随机给10名员工分配部门和工资；

  4. 通过multimap进行信息的插入 key(部门编号) value(员工)；

  5. 分部门显示员工信息。

3.10.2、实现步骤

  1. 创建10名员工，放到vector中

  2. 遍历vector容器，取出每个员工，进行随机分组

  3. 分组后，将员工部门编号作为key，具体员工作为value，放入到multimap容器中

  4. 分部门显示员工信息

案例代码：

#include <iostream>
#include <vector>
#include <string>
#include <map>
#include <ctime>
using namespace std;

/*
- 公司今天招聘了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<Worker>::iterator it = vWorker.begin(); it != vWorker.end(); it++) {
		cout << "姓名：" << it->m_Name << "，工资： " << it->m_Salary << endl;
	}

	system("pause");
	return 0;
}

总结：当数据以键值对形式存在，可以考虑用map或multimap。

upward337
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
c++STL常用容器之Stack容器——全面总结（附案例解析）（十四）
cfl997
11-24 7967
这里有C++STL——全面总结详细教程（附案例解析）（持续更新中） 目录 stack容器 stack 基本概念 stack 常用接口 stack容器 stack 基本概念 概念：stack是一种先进后出(First In Last Out,FILO)的数据结构，它只有一个出口 栈中只有顶端的元素才可以被外界使用，因此栈不允许有遍历行为 栈中进入数据称为 --...
【贪玩巴斯】C++提高编程，掌握STL中最关键的容器技术~（三）{map、set、list、queue、stack 五大容器一篇解决！} //2021-08-25
D16100的博客
08-25 280
// day_03 // Created by AchesonD16 贪玩巴斯 on 2021/8/19. 1. stack容器 （栈） 1.1 stack 基本概念 栈 概念： stack是一种先进后出(First In Last Out,FILO)的数据结构，它只有一个出口，后进先出 栈中只有顶端的元素才可以被外界使用，因此栈不允许有遍历行为 栈中进入数据称为 — 入栈 push 栈中弹出数据称为 — 出栈 pop 1.2 stack 常用接口 功能...
【C++】队列（queue）的基本用法
PuddleRubbish的博客
12-29 4757
队列（queue）是的，即遵循“”的数据结构。注意：只有队头和队尾能被外界访问，因此不允许有遍历行为。队头（front）：允许删除的一端，又称队首队尾（rear）：允许插入的一端空队列：不包含任何元素的空表。
STL11-stack容器
weixin_38383877的博客
07-22 109
#if 1 #include<iostream> #include<stack> using namespace std; void test01() { //初始化 stack<int> s1; stack<int> s2(s1); //stack操作 s1.push(10); s1.push(20); s1....
c++基础 STL 第四篇（queue容器和list容器）
呋喃吖的博客
07-12 2869
文章目录一 queue 容器的基本概念二 queue 容器常用操作三 list 容器的基本概念1 list 的构造函数2 list 的赋值和交换操作3 list 的大小操作4 list 的插入和删除5 list 的反转和排序 一 queue 容器的基本概念 概念：queue是一种先进先出(First In First Out,FIFO)的数据结构，队列容器允许从一端插入元素，从另一端移除元素。 说明： 通常队头为移除数据，队尾插入数据； 队列没有迭代器的操作，因为无法遍历数据，只能在队头和队尾操作数据；
C++标准库--stack 与其应用（栈元素的升序排列）
霜叶的博客
07-25 1998
参考 网址： https://blog.csdn.net/lanzhihui_10086/article/details/42426521（带有stack类的重新实现） https://blog.csdn.net/m0_37561165/article/details/81114441（c++标准库stack和queue的简单使用） 1、stack的引入和使用 stack存在于STD&lt...
C++ STL容器stack和queue详解
09-01
主要介绍了C++ STL容器stack和queue详解的相关资料,需要的朋友可以参考下
深入解析C++ STL中的常用容器
12-31
STL中的常用容器包括：顺序性容器（vector、deque、list）、关联容器（map、set）、容器适配器（queue、stac）。 1、顺序性容器 （1）vectorvector是一种动态数组，在内存中具有连续的存储空间，支持快速随机访问。...
c++中容器之总结篇
12-31
主要有：pair、set、map、multiset和multimap。 接下来依次对于各种容器做详细的介绍。 一、顺序容器 1、顺序容器定义 为了定义一个容器类型的对象，必须先包含相关的头文件：  定义vector：#include <vector
c++中的 栈 stack 用法
热门推荐
xueruifan的专栏
04-27 3万+
c++ stl栈stack介绍C++ Stack（堆栈） 是一个容器类的改编，为程序员提供了堆栈的全部功能，——也就是说实现了一个先进后出（FILO）的数据结构。c++ stl栈stack的头文件为:#include <stack>c++ stl栈stack的成员函数介绍操作 ...
C++ stack用法
一只大笨猫的博客
08-06 3万+
C++库以提供“模板”为主。所谓模板，是指不必预先制定类型的函数或类。我们可以借助STL（标准模板库 Standard Template Library, STL）提供的高效算法来管理数据。为应对多种需求，STL为用户提供了多种名为容器（Container）的类，用于管理数据集合。在创建动态数组、表、栈、队列等数据结构时，我们只需要定义对应的容器，然后调用相应成员函数或算法即可。 stack...
P4语言——mri
csdn_ggboy的博客
02-09 1787
练习：多跳监测 本教程的目的是用带内网络遥测(INT)的缩小版扩展基本的L3转发，我们称之为多跳路由检查(MRI)。 磁共振成像允许用户跟踪路径和队列长度，每个包经过。 为了支持这个功能，您需要编写一个P4程序，将ID和队列长度附加到每个包的头栈。 在目的端，交换机ID的顺序与路径对应，每个ID后面跟着交换机端口的队列长度。 P4文件 /* -*- P4_16 -*- */ #include <core.p4> #include <v1model.p4> const bit&lt
C++|C++ primer 第6章 函数
kllo__的博客
12-06 798
函数是一个命名了的代码块，我们通过调用函数执行相应的代码。函数可以有 0 或 多个参数，而且（通常）会产生一个结果。可以重载函数，也就是说，同一个名字可以对应几个不同的函数。 6.1 函数基础 一个典型的函数（function）定义包括以下部分：返回类型（return type）、函数名字、由 0 或多个形参（parameter）组成的列表及函数体。其中，形参以逗号隔开，形参的列表位于一对圆括号之内。函数执行的操作在语句块中说明，该语句块称为函数体（function bo...
C++ STL标准模板库-优秀的C++标准库
08-23
STL是Standard Template Library的简称，中文名标准模板库，是由Alexander Stepanov、Meng Lee和David R Musser在惠普实验室开发的 ，是一个具有工业强度的，高效的C++库，STL早已是ANSI/ISO C++标准中的一部分。STL库由于其对跨平台，对标准C++的支持，开源，高效等优点，如今已经被广泛运用于企业级开发。
C++ STL之queue容器，list 容器
xinlongkun的博客
11-09 841
入队： 出队 nclude<iostream> #include<queue> using namespace std; #include<string> class person { public: person(string name,int age) { this->m_Name=name; this->m_age=age; } string m_Name; int m_age; }; vo...
记录在P4中简单的INT遥测中遇到的问题
lixiaobobobo的博客
11-06 888
记录在P4可编程数据平面进行INT实验的一些问题
P4学习----Types and Parsers
老网工的岁月独白
03-29 613
Header是定义哪些数据报文的header可以使用，Parser是对headers里面的信息解析出来变成P4理解的数据结构。解析过程中存在若干个状态，状态之间可以转换。 Header Types 数据包通常包括一系列headers，每个header都是一系列字段。例如，以太网数据包具有以下结构： P4提供一种表示header的内置类型 可以使用标准的“.”符号访问header的每个组件，例如，如果可变以太网的类型为ethernet_t，则为ethernet.dstAddr表示目标地址。 header
C++11标准库(STL)使用总结
程序猿之家
09-06 6414
STL定义了强大的、基于模板的、可复用的组件，实现了许多通用的数据结构及处理这些数据结构的算法。其中包含三个关键组件——容器（container，流行的模板数据结构）、迭代器（iterator）和算法（algorithm）。 组件 描述 容器 容器是用来管理某一类对象的集合。C++ 提供了各种不同类型的容器，比如 deque、list、vector、map 等。 迭代器 迭代器...
C++11中STL总结+(boost库）
dongfang1984的博客
06-12 2565
用了快一年的STL库，决定写一下这一年的使用心得与总结。 1、概述个人觉得 STL == {算法，容器，迭代器}； 算法头文件： #include < algorithm > 迭代器头文件：#include < iterator > 各种容器： #include< map/ vector/ set / list / queue/ …>C++primer 上有一句非常经典的话“”算法操作容器
stl的容器,迭代器和算法具有哪些子概念？vector、depque、list,set,multiset,map,multimap各容器的迭代器分别属于哪种迭代器
最新发布
05-29
- 关联式容器：元素按照某种特定的规则进行排序，比如set、multiset、map、multimap。 - 容器适配器：用来修改现有容器接口的类模板，比如stack、queue。 2. 迭代器： - 输入迭代器：只能读取容器中的元素，不能...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

upward337

谢谢老板~

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值