C++ unordered_map和unordered_set的使用

Love The Way You Lie 2023-09-27 09:51 46阅读 0赞

### 目录 ###

*  一、unordered系列关联式容器
 *  二、unordered\_map
 *   *  1. unordered\_map介绍
     *  2. unordered\_map相关接口
 *  三、unordered\_set
 *   *  1. unordered\_set介绍
     *  2. unordered\_set相关接口
 *  四、在线OJ
 *   *  1. 重复n次的元素
     *  2. 两个数组的交集 I
     *  3. 两个数组的交集 II

# 一、unordered系列关联式容器 #

在C++98中，STL提供了底层为红黑树结构的一系列关联式容器，在查询时效率可达到 l o g 2 N log\_2 N log2N，即最差情况下需要比较红黑树的高度次，当树中的节点非常多时，查询效率也不理想。最好的查询是，进行很少的比较次数就能够将元素找到，因此**在C++11中，STL又提供了4个unordered系列的关联式容器，这四个容器与红黑树结构的关联式容器使用方式基本类似**，只是其底层结构不同，本文对unordered\_map和unordered\_set的用法进行介绍。

# 二、unordered\_map #

## 1. unordered\_map介绍 ##

[unordered\_map在线文档说明][unordered_map]

1.  unordered\_map是存储<key, value>键值对的关联式容器，其允许通过keys快速的索引到与其对应的value。
2.  在unordered\_map中，键值通常用于惟一地标识元素，而映射值是一个对象，其内容与此键关联。键和映射值的类型可能不同。
3.  在内部,unordered\_map没有对<kye, value>按照任何特定的顺序排序, 为了能在常数范围内找到key所对应的value，unordered\_map将相同哈希值的键值对放在相同的桶中。
4.  unordered\_map容器通过key访问单个元素要比map快，但它通常在遍历元素子集的范围迭代方面效率较低。
5.  unordered\_maps实现了直接访问操作符(operator\[\])，它允许使用key作为参数直接访问value。
6.  它的迭代器至少是前向迭代器。

## 2. unordered\_map相关接口 ##

1.  unordered\_map的构造

<table> 
 <thead> 
  <tr> 
   <th>函数声明</th> 
   <th>功能</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td><a href="https://cplusplus.com/reference/unordered_map/unordered_map/unordered_map/" rel="nofollow">unordered_map</a></td> 
   <td>构造不同格式的unordered_map对象</td> 
  </tr> 
 </tbody> 
</table>

1.  unordered\_map的容量

<table> 
 <thead> 
  <tr> 
   <th>函数声明</th> 
   <th>功能介绍</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td><a href="https://cplusplus.com/reference/unordered_map/unordered_map/empty/" rel="nofollow">bool empty() const</a></td> 
   <td>检测unordered_map是否为空</td> 
  </tr> 
  <tr> 
   <td><a href="https://cplusplus.com/reference/unordered_map/unordered_map/size/" rel="nofollow">size_t size() const</a></td> 
   <td>获取unordered_map的有效元素个数</td> 
  </tr> 
 </tbody> 
</table>

1.  unordered\_map的迭代器

<table> 
 <thead> 
  <tr> 
   <th>函数声明</th> 
   <th>功能介绍</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td><a href="https://cplusplus.com/reference/unordered_map/unordered_map/begin/" rel="nofollow">begin</a></td> 
   <td>返回unordered_map第一个元素的迭代器</td> 
  </tr> 
  <tr> 
   <td><a href="https://cplusplus.com/reference/unordered_map/unordered_map/end/" rel="nofollow">end</a></td> 
   <td>返回unordered_map最后一个元素下一个位置的迭代器</td> 
  </tr> 
  <tr> 
   <td><a href="https://cplusplus.com/reference/unordered_map/unordered_map/cbegin/" rel="nofollow">cbegin</a></td> 
   <td>返回unordered_map第一个元素的const迭代器</td> 
  </tr> 
  <tr> 
   <td><a href="https://cplusplus.com/reference/unordered_map/unordered_map/cend/" rel="nofollow">cend</a></td> 
   <td>返回unordered_map最后一个元素下一个位置的const迭代器</td> 
  </tr> 
 </tbody> 
</table>

1.  unordered\_map的元素访问

<table> 
 <thead> 
  <tr> 
   <th>函数声明</th> 
   <th>功能介绍</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td><a href="https://cplusplus.com/reference/unordered_map/unordered_map/operator%5B%5D/" rel="nofollow">operator[]</a></td> 
   <td>返回与key对应的value，没有一个默认值</td> 
  </tr> 
 </tbody> 
</table>

> 注意：该函数中实际调用哈希桶的插入操作，用参数key与V()构造一个默认值往底层哈希桶中插入，如果key不在哈希桶中，插入成功，返回V()，插入失败，说明key已经在哈希桶中，将key对应的value返回。

1.  unordered\_map的查询

<table> 
 <thead> 
  <tr> 
   <th>函数声明</th> 
   <th>功能介绍</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td><a href="https://cplusplus.com/reference/unordered_map/unordered_map/find/" rel="nofollow">iterator find(const K&amp; key)</a></td> 
   <td>返回key在哈希桶中的位置</td> 
  </tr> 
  <tr> 
   <td><a href="https://cplusplus.com/reference/unordered_map/unordered_map/count/" rel="nofollow">size_t count(const K&amp; key)</a></td> 
   <td>返回哈希桶中关键码为key的键值对的个数</td> 
  </tr> 
 </tbody> 
</table>

> 注意：unordered\_map中key是不能重复的，因此count函数的返回值最大为1

1.  unordered\_map的修改操作

<table> 
 <thead> 
  <tr> 
   <th>函数声明</th> 
   <th>功能介绍</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td><a href="https://cplusplus.com/reference/unordered_map/unordered_map/insert/" rel="nofollow">insert</a></td> 
   <td>向容器中插入键值对</td> 
  </tr> 
  <tr> 
   <td><a href="https://cplusplus.com/reference/unordered_map/unordered_map/erase/" rel="nofollow">erase</a></td> 
   <td>删除容器中的键值对</td> 
  </tr> 
  <tr> 
   <td><a href="https://cplusplus.com/reference/unordered_map/unordered_map/clear/" rel="nofollow">void clear()</a></td> 
   <td>清空容器中有效元素个数</td> 
  </tr> 
  <tr> 
   <td><a href="https://cplusplus.com/reference/unordered_map/unordered_map/swap/" rel="nofollow">void swap(unordered_map&amp;)</a></td> 
   <td>交换两个容器中的元素</td> 
  </tr> 
 </tbody> 
</table>

1.  unordered\_map的桶操作

<table> 
 <thead> 
  <tr> 
   <th>函数声明</th> 
   <th>功能介绍</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td><a href="https://cplusplus.com/reference/unordered_map/unordered_map/bucket_count/" rel="nofollow">size_t bucket_count()const</a></td> 
   <td>返回哈希桶中桶的总个数</td> 
  </tr> 
  <tr> 
   <td><a href="https://cplusplus.com/reference/unordered_map/unordered_map/bucket_size/" rel="nofollow">size_t bucket_size(size_t n)const</a></td> 
   <td>返回n号桶中有效元素的总个数</td> 
  </tr> 
  <tr> 
   <td><a href="https://cplusplus.com/reference/unordered_map/unordered_map/bucket/" rel="nofollow">size_t bucket(const K&amp; key)</a></td> 
   <td>返回元素key所在的桶号</td> 
  </tr> 
 </tbody> 
</table>

# 三、unordered\_set #

## 1. unordered\_set介绍 ##

[unordered\_set在线文档说明][unordered_set]

1.  unordered\_set是以特定顺序存储唯一元素的容器，它允许根据其值快速检索单个元素。
2.  在unordered\_set中，元素的值同时是其键，用于唯一标识它。键是不可变的，因此，unordered\_set中的元素在容器中一次都不能修改 ，但是可以插入和删除它们。
3.  在内部，unordered\_set中的元素不按任何特定顺序排序，而是根据其哈希值组织到存储桶中，以允许直接按其值快速访问各个元素（平均平均时间复杂度恒定）。
4.  unordered\_set容器比set容器通过其键访问单个元素的速度更快，但它通常在遍历元素子集的范围迭代方面效率较低。
5.  容器中的迭代器是前向迭代器。

## 2. unordered\_set相关接口 ##

1.  unordered\_set的构造

<table> 
 <thead> 
  <tr> 
   <th>函数声明</th> 
   <th>功能</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td><a href="https://cplusplus.com/reference/unordered_set/unordered_set/unordered_set/" rel="nofollow">unordered_set</a></td> 
   <td>构造不同格式的unordered_set对象</td> 
  </tr> 
 </tbody> 
</table>

1.  unordered\_set的容量函数

<table> 
 <thead> 
  <tr> 
   <th>函数声明</th> 
   <th>功能介绍</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td><a href="https://cplusplus.com/reference/unordered_set/unordered_set/empty/" rel="nofollow">bool empty() const</a></td> 
   <td>检测unordered_set是否为空</td> 
  </tr> 
  <tr> 
   <td><a href="https://cplusplus.com/reference/unordered_set/unordered_set/size/" rel="nofollow">size_t size() const</a></td> 
   <td>获取unordered_set的有效元素个数</td> 
  </tr> 
 </tbody> 
</table>

1.  unordered\_set的迭代器

<table> 
 <thead> 
  <tr> 
   <th>函数声明</th> 
   <th>功能介绍</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td><a href="https://cplusplus.com/reference/unordered_set/unordered_set/begin/" rel="nofollow">begin</a></td> 
   <td>返回unordered_set第一个元素的迭代器</td> 
  </tr> 
  <tr> 
   <td><a href="https://cplusplus.com/reference/unordered_set/unordered_set/end/" rel="nofollow">end</a></td> 
   <td>返回unordered_set最后一个元素下一个位置的迭代器</td> 
  </tr> 
  <tr> 
   <td><a href="https://cplusplus.com/reference/unordered_set/unordered_set/cbegin/" rel="nofollow">cbegin</a></td> 
   <td>返回unordered_set第一个元素的const迭代器</td> 
  </tr> 
  <tr> 
   <td><a href="https://cplusplus.com/reference/unordered_set/unordered_set/cend/" rel="nofollow">cend</a></td> 
   <td>返回unordered_set最后一个元素下一个位置的const迭代器</td> 
  </tr> 
 </tbody> 
</table>

1.  unordered\_set的查询

<table> 
 <thead> 
  <tr> 
   <th>函数声明</th> 
   <th>功能介绍</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td><a href="https://cplusplus.com/reference/unordered_set/unordered_set/find/" rel="nofollow">iterator find(const K&amp; key)</a></td> 
   <td>返回key在哈希桶中的位置</td> 
  </tr> 
  <tr> 
   <td><a href="https://cplusplus.com/reference/unordered_set/unordered_set/count/" rel="nofollow">size_t count(const K&amp; key)</a></td> 
   <td>返回哈希桶中关键码为key的键值对的个数</td> 
  </tr> 
 </tbody> 
</table>

> 注意：unordered\_set中key是不能重复的，因此count函数的返回值最大为1

1.  unordered\_set的修改操作

<table> 
 <thead> 
  <tr> 
   <th>函数声明</th> 
   <th>功能介绍</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td><a href="https://cplusplus.com/reference/unordered_set/unordered_set/insert/" rel="nofollow">insert</a></td> 
   <td>向容器中插入键值对</td> 
  </tr> 
  <tr> 
   <td><a href="https://cplusplus.com/reference/unordered_set/unordered_set/erase/" rel="nofollow">erase</a></td> 
   <td>删除容器中的键值对</td> 
  </tr> 
  <tr> 
   <td><a href="https://cplusplus.com/reference/unordered_set/unordered_set/clear/" rel="nofollow">void clear()</a></td> 
   <td>清空容器中有效元素个数</td> 
  </tr> 
  <tr> 
   <td><a href="https://cplusplus.com/reference/unordered_set/unordered_set/swap/" rel="nofollow">void swap(unordered_set&amp;)</a></td> 
   <td>交换两个容器中的元素</td> 
  </tr> 
 </tbody> 
</table>

1.  unordered\_set的桶操作

<table> 
 <thead> 
  <tr> 
   <th>函数声明</th> 
   <th>功能介绍</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td><a href="https://cplusplus.com/reference/unordered_set/unordered_set/bucket_count/" rel="nofollow">size_t bucket_count()const</a></td> 
   <td>返回哈希桶中桶的总个数</td> 
  </tr> 
  <tr> 
   <td><a href="https://cplusplus.com/reference/unordered_set/unordered_set/bucket_size/" rel="nofollow">size_t bucket_size(size_t n)const</a></td> 
   <td>返回n号桶中有效元素的总个数</td> 
  </tr> 
  <tr> 
   <td><a href="https://cplusplus.com/reference/unordered_set/unordered_set/bucket/" rel="nofollow">size_t bucket(const K&amp; key)</a></td> 
   <td>返回元素key所在的桶号</td> 
  </tr> 
 </tbody> 
</table>

# 四、在线OJ #

## 1. 重复n次的元素 ##

[重复n次的元素][n]

题目：

> 给你一个整数数组 nums ，该数组具有以下属性：  
> nums.length == 2 \* n.  
> nums 包含 n + 1 个 不同的 元素  
> nums 中恰有一个元素重复 n 次  
> 找出并返回重复了 n 次的那个元素。

示例 ：

> 输入：nums = \[1,2,3,3\]  
> 输出：3

思路与算法:

> 记重复 n 次的元素为 x。由于数组 nums 中有 n+1 个不同的元素，而其长度为 2n，那么数组中剩余的元素均只出现了一次。也就是说，我们只需要找到重复出现的元素即为答案。因此我们可以对数组进行一次遍历，并使用哈希集合存储已经出现过的元素。如果遍历到了哈希集合中的元素，那么返回该元素作为答案。

class Solution {
        
    public:
        int repeatedNTimes(vector<int>& nums) {
        
            unordered_set<int> set;
            for(auto num : nums)
            {
        
                if(set.count(num))
                {
        
                    return num;
                }
                set.insert(num);
            }
            
            //结果不存在
            return -1;
        }
    };

## 2. 两个数组的交集 I ##

[两个数组的交集 I][I]

题目：

> 给定两个数组 nums1 和 nums2 ，返回 它们的交集 。输出结果中的每个元素一定是 唯一 的。我们可以 不考虑输出结果的顺序 。

示例 1：

> 输入：nums1 = \[1,2,2,1\], nums2 = \[2,2\]  
> 输出：\[2\]

示例 2：

> 输入：nums1 = \[4,9,5\], nums2 = \[9,4,9,8,4\]  
> 输出：\[9,4\]  
> 解释：\[4,9\] 也是可通过的

思路与算法:

> 计算两个数组的交集，直观的方法是遍历数组 nums1，对于其中的每个元素，遍历数组 nums2 判断该元素是否在数组 nums2 中，如果存在，则将该元素添加到返回值。假设数组 nums1 和 nums2 的长度分别是 m 和 n，则遍历数组 nums1 需要O(m) 的时间，判断 nums1 中的每个元素是否在数组 nums2 中需要 O(n) 的时间，因此总时间复杂度是 O(mn)。  
> 如果使用哈希集合存储元素，则可以在O(1) 的时间内判断一个元素是否在集合中，从而降低时间复杂度。首先使用**两个集合分别存储两个数组中的元素**，然后遍历较小的集合，判断其中的每个元素是否在另一个集合中，如果元素也在另一个集合中，则将该元素添加到返回值。该方法的时间复杂度可以降低到 O(m+n)。

class Solution {
        
    public:
        vector<int> intersection(vector<int>& nums1, vector<int>& nums2) {
        
            unordered_set<int> set1;
            unordered_set<int> set2;
    
            vector<int> res;
    
            for(auto num : nums1)
            {
        
                set1.insert(num);
            }
            for(auto num : nums2)
            {
        
                set2.insert(num);
            }
    
            for(auto num : set2)
            {
        
                if(set1.count(num)==1)
                {
        
                    res.push_back(num);
                }
            }
            return res;
        }
    };

## 3. 两个数组的交集 II ##

[两个数组的交集 II][II]

题目：

> 给你两个整数数组 nums1 和 nums2 ，请你以数组形式返回两数组的交集。返回结果中每个元素出现的次数，应与元素在两个数组中都出现的次数一致（如果出现次数不一致，则考虑取较小值）。可以不考虑输出结果的顺序。

示例 1：

> 输入：nums1 = \[1,2,2,1\], nums2 = \[2,2\]  
> 输出：\[2,2\]

示例 2:

> 输入：nums1 = \[4,9,5\], nums2 = \[9,4,9,8,4\]  
> 输出：\[4,9\]

思路与算法:

> 由于同一个数字在两个数组中都可能出现多次，因此需要用哈希表存储每个数字出现的次数。对于一个数字，其在交集中出现的次数等于该数字在两个数组中出现次数的最小值。  
> 首先遍历第一个数组，并在哈希表中记录第一个数组中的每个数字以及对应出现的次数，然后遍历第二个数组，对于第二个数组中的每个数字，如果在哈希表中存在这个数字，则将该数字添加到答案，并减少哈希表中该数字出现的次数。  
> 为了降低空间复杂度，首先遍历较短的数组并在哈希表中记录每个数字以及对应出现的次数，然后遍历较长的数组得到交集。

class Solution {
        
    public:
        vector<int> intersect(vector<int>& nums1, vector<int>& nums2) {
        
            if(nums1.size() < nums2.size())
            {
        
                intersect(nums2, nums1);
            }
    
            unordered_map<int, int> map;
    
            for(auto num : nums1)
            {
        
                ++map[num];
            }
    
            vector<int> res;
    
            for(auto num : nums2)
            {
        
                if(map.count(num))
                {
        
                    res.push_back(num);
                    --map[num];
                }
                if(map[num]==0)
                {
        
                    map.erase(num);
                }
            }
            return res;
        }
    };

[unordered_map]: https://cplusplus.com/reference/unordered_map/unordered_map/?kw=unordered_map
[unordered_set]: https://cplusplus.com/reference/unordered_set/unordered_set/
[n]: https://leetcode.cn/problems/n-repeated-element-in-size-2n-array/
[I]: https://leetcode.cn/problems/intersection-of-two-arrays/
[II]: https://leetcode.cn/problems/intersection-of-two-arrays-ii/