unordered_set unordered_map的运用

本文为力扣哈希表操作，笔者初学者确实看到题解有点头蒙，特此查阅了资料，供自己和读者们交流分享～

• unordered_set

        1.定义：unordered_set 容器，可直译为“无序 set 容器”，即 unordered_set 容器和 set 容器很像，唯一的区别就在于 set 容器会自行对存储的数据进行排序，而 unordered_set 容器不会。

       2. 结构：哈希表 ，内部元素无序

       3. 操作时间：常数级

       4.头文件：#include<unordered_set>        并位于 std 命名空间中，因此：

#include <unordered_set>

using namespace std;

        5.属性：不再以键值对的形式存储数据，而是直接存储数据的值；

                    容器内部存储的各个元素的值都互不相等，且不能被修改；

                    不会对内部存储的数据进行排序。

                    一种类型的容器只能存放相同类型的元素

即 unordered_set 存储的都是键和值相等的键值对，为了节省存储空间，该类容器在实际存储时选择只存储每个键值对的值。

注意，此容器模板类中没有重载 [ ] 运算符，也没有提供 at() 成员方法。不仅如此，由于 unordered_set 容器内部存储的元素值不能被修改，因此无论使用那个迭代器方法获得的迭代器，都不能用于修改容器中元素的值。

• 具体操作：

1.定义

//定义 存储int类型
unordered_set<int> c1;

//同时C++对operator=进行了重载
unordered_set<int> c2;
c2 = c1;

//注意：必须保证c1 c2类型完全一致

1.1类模板

template < class Key,            //容器中存储元素的类型
           class Hash = hash<Key>,    //确定元素存储位置所用的哈希函数
           class Pred = equal_to<Key>,   //判断各个元素是否相等所用的函数
           class Alloc = allocator<Key>   //指定分配器对象的类型
           > class unordered_set;

//以上 4 个参数中，只有第一个参数没有默认值，这意味着如果我们想创建一个 unordered_set 容器，至少需要手动传递 1 个参数。

2.判空

//判断是否为空
 c1.empty();

3.判断元素个数

//获取元素个数 size()
 c1.size();

4.获取最大存储容量

//获取最大存储量 max_size()
 c1.max_size();

5.判断主键为1的元素出现的个数

    //value出现的次数 count() 返回匹配给定主键的元素的个数
    c1.count(1);
    

6.插入

    //插入函数 emplace()
    c1.emplace(1);
    
    //插入函数 emplace_hint() 使用迭代器
    c1.emplace_hint(ite_begin, 1);
    
    //插入函数 insert() 插入1
    c1.insert(1);

7.删除/清空

    //删除 erase()
    c1.erase(1);//1.迭代器 value 区域
    
    //清空 clear()
    c1.clear();
    

8.交换容器元素

    
    //交换 swap()
    c1.swap(c2);

9.查找值为key的元素，如果找到，就返回指向该元素的正向迭代器；反之，则返回尾后迭代器(结束迭代器)。

unordered_set.end(key)

全体成员函数：

• unordered_map

        结构：键值对。将key【键】和value【值】关联起来的容器。

        头文件：#include < unordered_map >

        属性：key值应该是唯一的，key和value的数据类型可以不相同。

        顺序性：无序 unordered_map存储元素时是哈希存储，所以根据key查找单个value为O(1)

        ​​​​​​​

template < class Key,                        //键值对中键的类型
           class T,                          //键值对中值的类型
           class Hash = hash<Key>,           //容器内部存储键值对所用的哈希函数
           class Pred = equal_to<Key>,       //判断各个键值对键相同的规则
           class Alloc = allocator< pair<const Key,T> >  //指定分配器对象的类型
           > class unordered_map;

//以上 5 个参数中，必须显式给前 2 个参数传值，并且除特殊情况外，最多只需要使用前 4 个参数，各自的含义和功能如表 1 所示。

• 具体操作

1.初始化

//创建一个key为string类型，value为int类型的unordered_map
unordered_map<string, int> map;

2.插入元素        

//使用变量方式，插入一个元素
map.emplace("abc", 7);

//数组形式
map['a'] = 1;

//直接插入
map.insert( { {'b',2} , {'c',3} } );

3.访问/修改元素

//通过key值来访问value
map["abc"];

//修改
map['a'] = 0;

4.删除元素

//删除key为'a'的元素
map.erase('a'); 
 
//删除第一个元素
map.erase(map.begin());

5.判断元素是否存在

//判断键a对应元素是否存在
if(map.find('a')!=map.end())

if(map.count('a')!=0)

6.清空全体元素

map.clear();

7.判断是否为空

if( map.empty() )

8.遍历并求出全体键值对

//方法一
for( auto& a : map)
{
    char key= a.first;
    int  value= a.second;
}
 
//方法二
for (auto it = map.begin(); it != map.end(); it++) 
{
		char key = it->first;
        int  value = it->second;
}

/*
auto为迭代器用法
*/

10.求出元素个数

map.size();

全体成员函数