stl容器的使用：list、set、map、multimap

最新推荐文章于 2023-08-03 16:46:23 发布

QaoKi

最新推荐文章于 2023-08-03 16:46:23 发布

阅读量153

点赞数

分类专栏： stl容器

本文链接：https://blog.csdn.net/qq_32323543/article/details/88567148

版权

stl容器专栏收录该内容

2 篇文章 0 订阅

订阅专栏

list：

#define _CRT_SECURE_NO_WARNINGS
#include "iostream"
#include <windows.h>

#include "list"
#include "queue"
using namespace std;

//list 是一个双向链表容器
//list不可以随机存取元素，所以不支持at.(pos)函数与[]操作符；

//list基本操作
void main01()
{
	list<int> li;
	for (int i = 0; i < 10; i++)
	{
		li.push_back(i + 1);
	}
	cout << "list的大小：" << li.size() << endl;

	//遍历
	for (list<int>::iterator it = li.begin(); it != li.end(); it++)  //不支持 it+5 这种随机选元素的操作
	{
		cout << *it << "  ";
	}

	list<int>::iterator it = li.begin();//指向0号位置
	it++;
	it++;
	it++; //此时it指向3号位置
	li.insert(it, 100); //在3号位置插入元素，是让原来的3号位置变成4号位置，原来的4号位置变成5号位置
	                    //所以100 会插到3的前面

	//删除操作
	//li.clear(); //清空 list
	//li.erase(pos);    删除pos位置数据，返回下一数据的位置
	//li.remove(num)    删除容器中所有与num 值匹配的元素

	list<int>::iterator it1 = li.begin();
	list<int>::iterator it2 = li.begin(); //指向0号位置
	it2++; 
	it2++; 
	it2++; //指向3号位置
	li.erase(it1, it2); //list.erase(beg,end);//删除区间的元素，[beg,end),左闭右开，前面的删除，后面的不删
										  //li.erase(0,3);会把0号1号2号位置删除，3号位置不删除，返回下一数据的位置
}

//优先级队列 priority_queue   // 用 queue.h
//最大值优先级队列，最小值优先级队列
void main02()
{
	/*
	它的模板声明带有三个参数，priority_queue<Type, Container, Functional>
Type 为数据类型， Container 为保存数据的容器，Functional 为元素比较方式。
Container 必须是用数组实现的容器，比如 vector, deque 但不能用 list.
STL里面默认用的是 vector. 比较方式默认用 operator< , 所以如果你把后面俩个
参数缺省的话，优先队列就是大顶堆，队头元素最大。
	*/

	priority_queue<int> p1; //默认是最大值优先级队列，将一个元素放进去以后，把最大值放在头部

	priority_queue<int, vector<int>, less<int>> p2;  //最大值优先级队列

//	priority_queue<int, vector<int>, greater<int> > p3; //最小值优先级队列

	p1.push(1);
	p1.push(3);
	p1.push(2);
	p1.push(5);
	cout << "头部元素为：" << p1.top() << endl;
}

int main()
{
	//main01();
	main02();
	system("pause");
	return 0;
}

set：

#define _CRT_SECURE_NO_WARNINGS
#include "iostream"
#include <windows.h>

#include "set"

using namespace std;


//1.set 容器是一个集合容器，元素唯一，集合中的元素按一定顺序自动排列（会自动比较大小，默认从小到大），元素插入过程是按排序规则插入，所以不能指定插入位置
//2.按红黑树规则
void main01()
{
	set<int> set1;
	set<int, less<int>> set2; //从小到大
	//set<int, greater<int>> set3;//从大到小
	//插入元素
	for (int i = 0; i < 5; i++)
	{
		int tem = rand();
		set1.insert(tem);
	}
	//遍历
	for (set<int>::iterator it = set1.begin(); it != set1.end(); it++)
	{
		cout << *it << "  ";
	}
	//删除元素
	while (!set1.empty())
	{
		set1.erase(set1.begin());
	}
	cout << set1.size() << endl;
}

//自定义数据类型的排序 ==》仿函数
class Student
{
public:
	Student(int age, char * name)
	{
		this->age = age;
		strcpy(this->name,name);
	}

public:
	int age;
	char name[32];

};

//仿函数
struct FuncStu
{
	bool operator()(const Student &left, const Student &right)
	{
		if (left.age < right.age) //如果左边的小，返回真，按年龄从小到大排序
		{
			return true;
		}
		else
		{
			return false;
		}
	}
};

void main02()
{

	Student s1(31, "31");
	Student s2(22, "22");
	Student s3(44, "44");
	Student s4(35, "35");
	Student s5(31, "21");   
	set<Student, FuncStu> set1; //加上仿函数，按年纪从小到大排序
	set1.insert(s1);
	set1.insert(s2);
	set1.insert(s3);
	set1.insert(s4);
	set1.insert(s5); //因为set容器中 元素事唯一的，所以，如果按年龄进行排序的话，s5和s1的年龄相同，s5不会进入set容器


	//如何知道 insert操作是否成功，加断点，F11进去，insert返回 _Pairib 再F12 pair<iterator, bool>;
	//pair<iterator, bool>  ：对组
	pair<set<Student, FuncStu>::iterator,bool> pair1 = set1.insert(s5);
	if (pair1.second == true)
	{
		cout << "插入成功" << endl;
	}
	else
	{
		cout << "插入失败" << endl;
	}

	//遍历
	for (set<Student, FuncStu>::iterator it = set1.begin(); it != set1.end(); it++)
	{
		cout << it->age << "  " << it->name << endl;
	}

}

//set容器 查找
void main03()
{
	//set.fin(elem);  查找elem元素，返回指向elem元素的迭代器
	//set.coount(elem); 返回容器中值为elem的元素的个数，对set来说，要么是0 ，要么是1 ，对multiset来说，值可能大于1
	//set.lower_bound(elem);返回第一个 >= elem 元素的迭代器
	//set.upper_bound(elem); 返回第一个>elem元素的迭代器
	//set.equal_range(elem); 返回容器中与elem相等的上下限的两个迭代器，上限是闭区间，下限去开区间，如[beg,end)
	//						 返回的两个迭代器，封装在pair中
    //								pair<set<int>::iterator,ste<int>::iterator> pair1 = set.equal_range(5);
	//								第一个是>=5的迭代器，第二个是>5的迭代器
}


//multiset
//multiset 与 set 区别：set中每个元素值只能出现一次，multiset中同一值可以出现多次
void main04()
{


}

int main()
{

	//main01();
	//main02();
	//main03();
	main04();
	system("pause");
	return 0;
}

map：

#define _CRT_SECURE_NO_WARNINGS
#include "iostream"
#include <windows.h>
#include <string>

#include "map"

using namespace std;

//map容器
//1.map是标准的关联式容器，一个map是一个键值对序列，即(key,value)对，提供基于key的快速检索能力
//2.map中 key 是唯一的，集合中的元素按一定的顺序排列，元素插入过程是按排序规则插入，所以不能指定插入位置
//3.map的具体实现采用红黑树变体的平衡二叉树的数据结构，插入和删除操作比 vector快
//4.map可以直接存取key所对应的 value，支持[]操作符，如map[key] = value
//5.multimap 与 map 的区别：map支持唯一键值，每个键只能出现一次，而multimap 中相同键值可以出现多次，multimap不支持[]操作符

//map元素的添加、遍历、删除
void main01()
{
	map<int,string> map1;

	//添加：
	//方法1
	map1.insert(pair<int, string>(1, "tea01"));  //pair就是对组，可以直接插入map

	//方法2
	map1.insert(make_pair(2,"tea02"));

	//方法3
	map1.insert(map<int,string>::value_type(3,"tea03"));

	//方法4
	map1[4] = "tea04";

	//遍历
	for (map<int, string>::iterator it = map1.begin(); it != map1.end(); it++)
	{
		cout << it->first << "  " << it->second << endl;
	}

	//删除
	while (!map1.empty())
	{
		map<int, string>::iterator it = map1.begin();
		map1.erase(it);
	}
}

//插入的四种方法的异同
//前三种方法返回 pair<iterator,bool>,first为插入的迭代器位置，second为是否成功
void main02()
{
	map<int, string> map1;

	//添加：
	//方法1
	pair<map<int,string>::iterator,bool> mypair1 = map1.insert(pair<int, string>(1, "tea01"));  //pair就是对组，可以直接插入map
	if (mypair1.second != true)
	{
		cout << "插入失败" << endl;
	}
	else
	{
		cout << mypair1.first->first << "  " << mypair1.first->second << endl;
	}

	//方法2
	map1.insert(make_pair(2, "tea02"));

	//方法3
	map1.insert(map<int, string>::value_type(3, "tea03"));

	//方法4
	map1[4] = "tea04";

	//如果 key 已经存在，再用前三种方法插入会返回错误，而用第四种会将之前的 value 覆盖
}

//map 查找
//map.find(key);	查找键key是否存在，若存在，返回该键的元素的迭代器；若不存在，返回map.end();
//map.count(keyElem);  返回容器中key为keyElem的对组个数，对map来说，要么是0，要么是1，对multimap来说，值可能大于1
//map.equal_range(elem);返回两个迭代器，形成一个pair
void main03()
{
	map<int, string> map1;
	//添加：
	//方法1
	map1.insert(pair<int, string>(1, "tea01"));  //pair就是对组，可以直接插入map

	//方法2
	map1.insert(make_pair(2, "tea02"));

	//方法3
	map1.insert(map<int, string>::value_type(3, "tea03"));

	//方法4
	map1[4] = "tea04";

	pair<map<int, string>::iterator, map<int, string>::iterator> mypair = map1.equal_range(2);
	//mypair 的第一个迭代器：mypair.first 存放 >= 2 的位置 若没找到，返回map.end()
	//mypair 的第二个迭代器：mypair.second 存放 > 2 的位置 若没找到，返回map.end()
	if (mypair.first == map1.end())
	{
		cout << "没有找到" << endl;
	}
	if (mypair.second == map1.end())
	{
		cout << "没有找到" << endl;
	}
	

}
int main()
{
	//main01();
	//main02();
	main03();
	system("pause");
	return 0;
}

multimap：

#define _CRT_SECURE_NO_WARNINGS
#include "iostream"
#include <windows.h>
#include <string>
#include "map"

using namespace std;

//multimap案例
//1个Key值可以对应多个value ==>分组
/*
	公司有销售部 sale（员工2名）、技术研发部 development(1人)、财务部 financial(2人)
	人员信息有：姓名、年龄、电话、工资
	通过multimap进行 信息的插入、保存和显示
	分部门显示员工信息
*/
class Person
{
public:
	string name;
	int		age;
	string tel;
	double saly;
};

void main01()
{
	Person p1, p2, p3, p4, p5;
	p1.name = "王1";
	p1.age = 31;
	p2.name = "王2";
	p2.age = 32;
	p3.name = "李3";
	p3.age = 33;
	p4.name = "赵4";
	p4.age = 34;
	p5.name = "赵5";
	p5.age = 35;
	multimap<string, Person> map1;

	//sale部门
	map1.insert(make_pair("sale", p1));
	map1.insert(make_pair("sale", p2));
	//development部门
	map1.insert(make_pair("development", p3));
	//financial部门
	map1.insert(make_pair("financial", p4));
	map1.insert(make_pair("financial", p5));

	//遍历
	for (multimap<string, Person>::iterator it = map1.begin(); it != map1.end(); it++)
	{
		std::cout<<  it->first <<"   "<< it->second.name << endl;
	}


}

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