【C++】set、multiset与map、multimap的使用

2024-03-03 22:12

本文主要是介绍【C++】set、multiset与map、multimap的使用,希望对大家解决编程问题提供一定的参考价值,需要的开发者们随着小编来一起学习吧!

目录

  • 一、关联式容器
  • 二、键值对
  • 三、树形结构的关联式容器
    • 3.1 set
      • 3.1.1 模板参数列表
      • 3.1.2 构造
      • 3.1.3 迭代器
      • 3.1.4 容量
      • 3.1.5 修改操作
    • 3.2 multiset
    • 3.3 map
      • 3.3.1 模板参数列表
      • 3.3.2 构造
      • 3.3.3 迭代器
      • 3.3.4 容量
      • 3.3.5 修改操作
      • 3.3.6 operator[]
    • 3.4 multimap

一、关联式容器

谈到关联式容器,先来说说序列式容器,以前学习的vector、list、deque等就是序列式容器,它们的特点是底层为线性序列的数据结构,存储的是元素本身。关联式容器也是存储数据的,不同的是,里面存储的是<key, value>结构的键值对,在数据检索时比序列式容器效率更高。

二、键值对

键值对是用来表示一一对应关系的结构该结构中一般只包含两个成员变量key和value,key代表键值,value表示与key对应的信息,比如汉英互译字典,查中文就可以找到对应的英文,是有对应关系的。

键值对的定义:

template <class T1, class T2>
struct pair
{
typedef T1 first_type;
typedef T2 second_type;
T1 first;
T2 second;
pair(): first(T1()), second(T2())
{}
pair(const T1& a, const T2& b): first(a), second(b)
{}
};

三、树形结构的关联式容器

STL总共有两种结构的关联式容器,分别是哈希结构和树形结构。树形结构主要有4种:set、multiset、map、multimap,它们的共同点是底层是平衡搜索树即红黑树实现的,且容器中的元素是一个有序的序列。

3.1 set

特点:

  1. 遍历set中的元素,可以得到一个有序序列,因为它的底层实现是红黑树,再底层是二叉搜索树,遍历方式是中序遍历。
  2. set中的元素不可以重复,因此可以用set去重。
  3. 与map/multimap不同,map/multimap中存储的是真正的键值对<key, value>,set中只放value,但在底层实际存放的是由<value, value>构成的键值对。
  4. set中插入元素时,只需要插入value即可,不需要构造键值对。
  5. set中的元素默认按照小于来比较。
  6. set中查找某个元素,时间复杂度为:logN,即最多高度次。
  7. 在内部,set中的元素总是按照其内部比较对象(类型比较)所指示的特定严格弱排序准则进行排序。
  8. set容器通过key访问单个元素的速度通常比unordered_set容器慢,但它们允许根据顺序对子集进行直接迭代。
  9. set中的元素不允许修改,因为修改了其中的一个元素会改变内部的结构,从而影响有序性。
  10. set在底层是用二叉搜索树(红黑树)实现的。

3.1.1 模板参数列表

在这里插入图片描述

  • T: set中存放元素的类型,实际在底层存储<value, value>的键值对。
  • Compare:set中元素默认按照小于来比较。
  • Alloc:set中元素空间的管理方式,使用STL提供的空间配置器管理。

3.1.2 构造

1️⃣构造空的set:

set<int> s;

2️⃣用迭代器区间构造:

set<int> s1(s.begin(), s.end());

3️⃣拷贝构造:

set<int> s2(s);

3.1.3 迭代器

1️⃣begin+end
正向遍历

	set<int> s;s.insert(1);s.insert(3);s.insert(3);s.insert(3);s.insert(5);s.insert(2);set<int>::iterator it = s.begin();while (it != s.end()){cout << *it << " ";++it;}cout << endl;

这里顺便检验下是否去重且有序:
在这里插入图片描述

2️⃣rbegin+rend
与上面类似,只不过是反向遍历

	set<int>::reverse_iterator rit = s.rbegin();while (rit != s.rend()){cout << *rit << " ";++rit;}cout << endl;

在这里插入图片描述

3.1.4 容量

1️⃣empty
判断set是否为空,空返回true,否则返回true

	set<int> s;cout << s.empty() << endl;//1

2️⃣size
返回set中有效元素的个数

set<int> s;
s.insert(1);
s.insert(3);
s.insert(3);
s.insert(3);
s.insert(5);
s.insert(2);
cout << s.size() << endl;//4

3.1.5 修改操作

1️⃣insert

pair<iterator,bool> insert ( const value_type& x )

在set中插入元素x,实际插入的是<x, x>构成的键值对,如果插入成功,返回<该元素在set中的位置,true>,如果插入失败,说明x在set中已经存在,返回<x在set中的位置,false>。

set<int> s;
s.insert(1);
s.insert(3);
s.insert(3);
s.insert(3);
s.insert(5);
s.insert(2);
for (auto& e : s)
{cout << e << " ";
}
cout << endl;

在这里插入图片描述

2️⃣erase
删除有三种方式:

删除set中position位置上的元素

void erase ( iterator position )

set<int> s;
s.insert(1);
s.insert(3);
s.insert(5);
s.insert(2);
for (auto& e : s)
{cout << e << " ";
}
cout << endl;
set<int>::iterator pos = s.begin();
s.erase(pos);
for (auto& e : s)
{cout << e << " ";
}

在这里插入图片描述

删除set中值为x的元素,返回删除的元素的个数

size_type erase ( const key_type& x )

set<int> s;
s.insert(1);
s.insert(3);
s.insert(5);
s.insert(2);
for (auto& e : s)
{cout << e << " ";
}
cout << endl;
s.erase(3);
for (auto& e : s)
{cout << e << " ";
}

在这里插入图片描述

删除set中[first, last)区间中的元素

void erase ( iterator first, iterator last )

set<int> s;
s.insert(1);
s.insert(3);
s.insert(5);
s.insert(2);
for (auto& e : s)
{cout << e << " ";
}
cout << endl;
s.erase(s.begin(), s.end());
for (auto& e : s)
{cout << e << " ";
}

在这里插入图片描述

3️⃣swap
交换set中的元素

void swap ( set<Key,Compare,Allocator>& st );

	set<int> s1;s1.insert(1);s1.insert(3);s1.insert(5);for (auto& e : s1){cout << e << " ";//1 3 5}cout << endl;set<int> s2;s2.insert(7);s2.insert(8);s2.insert(6);for (auto& e : s2){cout << e << " "; //6 7 8}cout << endl;s2.swap(s1);for (auto& e : s1){cout << e << " ";//6 7 8}cout << endl;for (auto& e : s2){cout << e << " ";//1 3 5}

4️⃣clear
将set中的元素清空

void clear ( )

set<int> s1;
s1.insert(1);
s1.insert(3);
s1.insert(5);
s1.clear();
for (auto& e : s1)
{cout << e << " ";// 空
}

5️⃣find
找到了,返回set中值为x的元素的位置,如果每找到,返回最后一个元素的下一个位置

iterator find ( const key_type& x ) const

set<int> s1;
s1.insert(1);
s1.insert(3);
s1.insert(5);
//s1.clear();
set<int>::iterator pos = s1.find(3);
if (pos != s1.end())cout << "找到了" << endl;//找到了
elsecout << "没找到" << endl;

6️⃣count
返回set中值为x的元素的个数,因为set是去重的,所以存在返回1,不存在返回0

size_type count ( const key_type& x ) const

set<int> s1;
s1.insert(1);
s1.insert(3);
s1.insert(5);
cout << s1.count(3) << endl;//1
cout << s1.count(33) << endl;//0

3.2 multiset

multiset与set的区别是存储的元素可以重复

void test_set8()
{multiset<int> s;s.insert(1);s.insert(3);s.insert(3);s.insert(5);s.insert(5);s.insert(5);s.insert(2);for (auto& e : s){cout << e << " ";//1 2 3 3 5 5 5}
}

还有接口与set的不同,分别是find和count

set的find与multiset的find
set不能有重复元素,所以找到了返回该元素的位置;multiset有重复元素,找到了返回该元素的第一个的位置。找不到都是返回end()

multiset<int> s;
s.insert(1);
s.insert(3);
s.insert(3);
multiset<int>::iterator pos = s.find(3);//返回第一个3的位置
while (pos != s.end())
{cout << *pos << " ";// 3 3++pos;
}
cout << endl;
}

set的count与multiset的count
set没有重复元素,所以存在的元素返回1,不存在返回0;multiset有重复元素,所以存在返回该元素的个数,不存在返回0

multiset<int> s;
s.insert(1);
s.insert(3);
s.insert(3);
s.insert(3);
s.insert(3);
cout << s.count(3) << endl;//4

3.3 map

与sert一样,map可以使容器的元素有序且去重
特点:

  1. map中的元素是键值对,由key和value组成
  2. 在map中,键值key通常用于排序和惟一地标识元素,而值value中存储与此键值key关联的内容。键值key和值value的类型可能不同,并且在map的内部,key与value通过成员类型value_type绑定在一起,为其取别名称为pair—— typedef pair<const key, T> value_type;
  3. 在内部,map中的元素总是按照键值key进行比较排序的
  4. map中的key是唯一的,并且不能修改
  5. map中通过键值访问单个元素的速度通常比unordered_map容器慢,但map允许根据顺序对元素进行直接迭代(即对map中的元素进行迭代时,可以得到一个有序的序列)。
  6. map支持下标访问符,可以进行插入、查找和修改
  7. map的底层为平衡搜索树(红黑树)

3.3.1 模板参数列表

在这里插入图片描述

  • key: 键值对中key的类型
  • T: 键值对中value的类型
  • Compare: 比较器的类型,map中的元素是按照key来比较的,缺省情况下按照小于来比较,一般情况下(内置类型元素)该参数不需要传递,如果无法比较时(自定义类型),需要用户自己显式传递比较规则(一般情况下按照函数指针或者仿函数来传递)
  • Alloc:通过空间配置器来申请底层空间,不需要用户传递,除非用户不想使用标准库提供的空间配置器

3.3.2 构造

1️⃣构造空的map

map<string, string> m;

2️⃣用迭代器区间进行构造

map<string, string> m1(m.begin(), m.end());

3️⃣拷贝构造

map<string, string> m2(m);

3.3.3 迭代器

1️⃣begin和end
正向遍历

map<string, string> m;
m.insert(pair<string, string>("sort", "排序"));
m.insert(pair<string, string>("apple", "苹果"));
m.insert(pair<string, string>("left", "左边"));
map<string, string>::iterator it = m.begin();
while (it != m.end())
{cout << *it << " ";//错误写法,编译报错++it;
}

因为map的每个元素是键值对,由key和value组成,即pair,而且它们的类型不一定相同,所以要用 . 或者 -> 指向对应的成员

map<string, string> m;
m.insert(pair<string, string>("sort", "排序"));
m.insert(pair<string, string>("sort", "排序"));
m.insert(pair<string, string>("sort", "排序"));
m.insert(pair<string, string>("apple", "苹果"));
m.insert(pair<string, string>("left", "左边"));
map<string, string>::iterator it = m.begin();
while (it != m.end())
{//cout << (*it).first << ":" << (*it).second << endl;cout << it->first << ":" << it->second << endl;++it;
}

在这里插入图片描述

2️⃣rbegin和rend
反向遍历

map<string, string>::reverse_iterator rit = m.rbegin();
while (rit != m.rend())
{//cout << (*rit).first << ":" << (*rit).second << endl;cout << rit->first << ":" << rit->second << endl;++rit;
}

在这里插入图片描述

3.3.4 容量

1️⃣empty
检测map中的元素是否为空,是返回true,否则返回false

map<string, string> m;
cout << m.empty() << endl;//1

2️⃣size
返回map中有效元素的个数

m.insert(pair<string, string>("left", "左边"));
cout << m.size() << endl;//1

3.3.5 修改操作

1️⃣insert

pair<iterator,bool> insert ( const value_type& x )

在map中插入的是键值对,返回值也是键值对,如果插入成功,则返回当前元素(键值对)的位置和true,插入失败,则返回原来已有的元素的位置和false

插入的方式有三种写法:

map<string, string> m;
m.insert(pair<string, string>("sort", "排序"));//C++98
m.insert(make_pair("apple", "苹果"));//C++98
m.insert({ "left", "左边" }); //C++11 多参数隐式类型转换

在这里插入图片描述

2️⃣erase
删除有3种方式,与set相同:

删除position位置上的元素

void erase ( iterator position )

map<string, string> m;
m.insert(make_pair("sort", "排序"));
m.insert(make_pair("apple", "苹果"));
m.insert(make_pair("left", "左边"));
for (auto& e : m)
{cout << e.first << ":" << e.second << " ";
}
cout << endl;
map<string, string>::iterator pos = m.begin();
m.erase(pos);
for (auto& e : m)
{cout << e.first << ":" << e.second << " ";
}

在这里插入图片描述

删除键值为x的元素

size_type erase ( const key_type& x )

m.erase("sort");

在这里插入图片描述

删除[first, last)区间中的元素

void erase ( iterator first, iterator last )

m.erase(m.begin(), m.end());

3️⃣swap
交换两个map中的元素

void swap ( map<Key,T,Compare,Allocator>& mp )

map<string, string> m1;
m1.insert(make_pair("sort", "排序"));
m1.insert(make_pair("apple", "苹果"));
for (auto& e : m1)
{cout << e.first << ":" << e.second << " ";
}
map<string, string> m2;
m2.insert(make_pair("left", "左边"));
m2.insert(make_pair("right", "右边"));
for (auto& e : m2)
{cout << e.first << ":" << e.second << " ";
}
m2.swap(m1);
for (auto& e : m1)
{cout << e.first << ":" << e.second << " ";
}
for (auto& e : m2)
{cout << e.first << ":" << e.second << " ";
}

在这里插入图片描述

4️⃣clear
将map中的元素清空

void clear ( )

map<string, string> m;
m.insert(make_pair("sort", "排序"));
m.clear();
cout << m.empty() << endl;//1

5️⃣find
查找key为x的元素,找到了返回该元素的迭代器,找不到返回end

iterator find ( const key_type& x )

map<string, string> m;
m.insert(make_pair("sort", "排序"));
map<string, string>::iterator pos = m.find("sort");
if (pos != m.end())cout << "找到了" << endl;//找到了
elsecout << "没找到" << endl;

6️⃣count
返回key为x在map中的个数,由于map会去重,所以存在返回1,不存在返回0

size_type count ( const key_type& x ) const

map<string, string> m;
m.insert(make_pair("sort", "排序"));
m.insert(make_pair("sort", "排序"));
cout << m.count("sort") << endl;//1
cout << m.count("apple") << endl;//0

3.3.6 operator[]

mapped_type& operator[] (const key_type& k);

该函数的参数是key,返回值是value。可以用来插入、查找、修改和计数。先来看看使用:

1️⃣插入:如果key没有重复,插入成功

map<string, string> m;
m.insert(make_pair("sort", "排序"));
m["left"];//插入
for (auto& e : m)
{cout << e.first << ":" << e.second << endl;
}

在这里插入图片描述

2️⃣查找:插入的key已经存在,查找到该key对应的value

map<string, string> m;
m.insert(make_pair("sort", "排序"));
m.insert(make_pair("apple", "苹果"));
cout << m["apple"] << endl;//苹果

3️⃣修改:插入的key已经存在,同时右边如下代码所示,将该key对应的value修改

map<string, string> m;
m.insert(make_pair("sort", "排序"));
m.insert(make_pair("apple", "苹果"));
m["sort"] = "排序的英文";
for (auto& e : m)
{cout << e.first << ":" << e.second << endl;
}

在这里插入图片描述

4️⃣插入+修改:插入key没有重复,且右边如下代码所示,修改对应的value(其实是补上)

map<string, string> m;
m.insert(make_pair("sort", "排序"));
m.insert(make_pair("apple", "苹果"));
m["left"] = "左边";
for (auto& e : m)
{cout << e.first << ":" << e.second << endl;
}

在这里插入图片描述

5️⃣统计次数

map<string, int> m;
string arr[] = { "sort","sort" ,"apple" ,"apple", "banana","one" };
for (auto& e : arr)
{m[e]++;
}
for (auto& e : m)
{cout << e.first << ":" << e.second << " ";cout << endl;
}

在这里插入图片描述

接下来看看operator[]是如何实现以上操作的:
在这里插入图片描述

operator[]内部其实调用了insert函数
在这里插入图片描述
我们再来看看insert函数:
在这里插入图片描述
回顾下,insert函数的要插入的数据类型是键值对
在这里插入图片描述
它的返回类型也是键值对,operator[]调用insert函数得到的返回值是迭代器,对迭代器解引用然后点访问迭代器的第二个成员,最后返回该成员。

梳理下:
首先看operator[]调用insert函数,而insert里面的make_pair是(k, mapped_type()),也就是说key值是要输入的,而value我们不写编译器帮我们默认构造出来,int类型是0。接着insert函数就要返回了,返回的是键值对,插入成功,返回该位置的迭代器和true;插入失败,返回该位置的迭代器和false。.first,得到返回值的第一个成员,即迭代器。迭代器的本质是指针,指针指向的是该位置的key和对应的value,解引用指针,然后最后的 .second 得到是该迭代器的value,即插入的key对应的value

3.4 multimap

multimap与map的区别和multiset与set的区别相同,都能形成有序,但是multimap可以允许元素重复

multimap<string, string> m;
m.insert(make_pair("sort", "排序"));
m.insert(make_pair("sort", "排序"));
m.insert(make_pair("left", "左边"));
m.insert(make_pair("sort", "排序"));
m.insert(make_pair("apple", "苹果"));
m.insert(make_pair("apple", "苹果"));
for (auto& e : m)
{cout << e.first << ":" << e.second << " ";cout << endl;
}

在这里插入图片描述

还有find和count:

map的find与multimap的find
map返回该元素的迭代器,multimap返回该元素的第一个的迭代器

multimap<string, string> m;
m.insert(make_pair("sort", "排序"));
m.insert(make_pair("sort", "排序"));
m.insert(make_pair("apple", "苹果"));
multimap<string, string>::iterator pos = m.find("sort");
while (pos != m.end())
{cout << pos->first << ":" << pos->second << endl;++pos;
}

在这里插入图片描述

map的count与multimap的count
map没有重复元素,所以该元素存在返回1,不存在返回0;multimap可以有重复元素,存在返回该元素的个数,不存在返回0

multimap<string, string> m;
m.insert(make_pair("sort", "排序"));
m.insert(make_pair("sort", "排序"));
m.insert(make_pair("apple", "苹果"));
cout << m.count("sort") << endl;//2
cout << m.count("apple") << endl;//1
cout << m.count("left") << endl;//0

这篇关于【C++】set、multiset与map、multimap的使用的文章就介绍到这儿,希望我们推荐的文章对编程师们有所帮助!



http://www.chinasem.cn/article/771078

相关文章

中文分词jieba库的使用与实景应用(一)

知识星球:https://articles.zsxq.com/id_fxvgc803qmr2.html 目录 一.定义: 精确模式(默认模式): 全模式: 搜索引擎模式: paddle 模式(基于深度学习的分词模式): 二 自定义词典 三.文本解析   调整词出现的频率 四. 关键词提取 A. 基于TF-IDF算法的关键词提取 B. 基于TextRank算法的关键词提取

使用SecondaryNameNode恢复NameNode的数据

1)需求: NameNode进程挂了并且存储的数据也丢失了,如何恢复NameNode 此种方式恢复的数据可能存在小部分数据的丢失。 2)故障模拟 (1)kill -9 NameNode进程 [lytfly@hadoop102 current]$ kill -9 19886 (2)删除NameNode存储的数据(/opt/module/hadoop-3.1.4/data/tmp/dfs/na

Hadoop数据压缩使用介绍

一、压缩原则 (1)运算密集型的Job,少用压缩 (2)IO密集型的Job,多用压缩 二、压缩算法比较 三、压缩位置选择 四、压缩参数配置 1)为了支持多种压缩/解压缩算法,Hadoop引入了编码/解码器 2)要在Hadoop中启用压缩,可以配置如下参数

Makefile简明使用教程

文章目录 规则makefile文件的基本语法:加在命令前的特殊符号:.PHONY伪目标: Makefilev1 直观写法v2 加上中间过程v3 伪目标v4 变量 make 选项-f-n-C Make 是一种流行的构建工具,常用于将源代码转换成可执行文件或者其他形式的输出文件(如库文件、文档等)。Make 可以自动化地执行编译、链接等一系列操作。 规则 makefile文件

【C++ Primer Plus习题】13.4

大家好,这里是国中之林! ❥前些天发现了一个巨牛的人工智能学习网站,通俗易懂,风趣幽默,忍不住分享一下给大家。点击跳转到网站。有兴趣的可以点点进去看看← 问题: 解答: main.cpp #include <iostream>#include "port.h"int main() {Port p1;Port p2("Abc", "Bcc", 30);std::cout <<

使用opencv优化图片(画面变清晰)

文章目录 需求影响照片清晰度的因素 实现降噪测试代码 锐化空间锐化Unsharp Masking频率域锐化对比测试 对比度增强常用算法对比测试 需求 对图像进行优化,使其看起来更清晰,同时保持尺寸不变,通常涉及到图像处理技术如锐化、降噪、对比度增强等 影响照片清晰度的因素 影响照片清晰度的因素有很多,主要可以从以下几个方面来分析 1. 拍摄设备 相机传感器:相机传

C++包装器

包装器 在 C++ 中,“包装器”通常指的是一种设计模式或编程技巧,用于封装其他代码或对象,使其更易于使用、管理或扩展。包装器的概念在编程中非常普遍,可以用于函数、类、库等多个方面。下面是几个常见的 “包装器” 类型: 1. 函数包装器 函数包装器用于封装一个或多个函数,使其接口更统一或更便于调用。例如,std::function 是一个通用的函数包装器,它可以存储任意可调用对象(函数、函数

C++11第三弹:lambda表达式 | 新的类功能 | 模板的可变参数

🌈个人主页: 南桥几晴秋 🌈C++专栏: 南桥谈C++ 🌈C语言专栏: C语言学习系列 🌈Linux学习专栏: 南桥谈Linux 🌈数据结构学习专栏: 数据结构杂谈 🌈数据库学习专栏: 南桥谈MySQL 🌈Qt学习专栏: 南桥谈Qt 🌈菜鸡代码练习: 练习随想记录 🌈git学习: 南桥谈Git 🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈�

【C++】_list常用方法解析及模拟实现

相信自己的力量,只要对自己始终保持信心,尽自己最大努力去完成任何事,就算事情最终结果是失败了,努力了也不留遗憾。💓💓💓 目录   ✨说在前面 🍋知识点一:什么是list? •🌰1.list的定义 •🌰2.list的基本特性 •🌰3.常用接口介绍 🍋知识点二:list常用接口 •🌰1.默认成员函数 🔥构造函数(⭐) 🔥析构函数 •🌰2.list对象

06 C++Lambda表达式

lambda表达式的定义 没有显式模版形参的lambda表达式 [捕获] 前属性 (形参列表) 说明符 异常 后属性 尾随类型 约束 {函数体} 有显式模版形参的lambda表达式 [捕获] <模版形参> 模版约束 前属性 (形参列表) 说明符 异常 后属性 尾随类型 约束 {函数体} 含义 捕获:包含零个或者多个捕获符的逗号分隔列表 模板形参:用于泛型lambda提供个模板形参的名