205-C++hash_set

最新推荐文章于 2024-06-12 22:27:34 发布
最新推荐文章于 2024-06-12 22:27:34 发布
阅读量252 收藏
点赞数
分类专栏： C++ 文章标签： C++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45964837/article/details/123011945
版权 

#ifndef YHP_HASH_SET_H
#define YHP_HASH_SET_H
#include"yhp_hashtable.h"
namespace yhp
{

template <class _Tp>
struct _Identity : public unary_function<_Tp,_Tp> 
{
	const _Tp& operator()(const _Tp& __x) const { return __x; }
};

template <class _Value, class _HashFcn = hash<_Value>,
          class _EqualKey = equal_to<_Value>,
          class _Alloc = alloc >

class hash_set
{
private:
	typedef hashtable<_Value, _Value, _HashFcn, _Identity<_Value>,_EqualKey, _Alloc> _Ht;
	_Ht _M_ht;

public:
  typedef typename _Ht::key_type key_type;
  typedef typename _Ht::value_type value_type;
  typedef typename _Ht::hasher hasher;
  typedef typename _Ht::key_equal key_equal;

  typedef typename _Ht::size_type size_type;
  typedef typename _Ht::difference_type difference_type;
  typedef typename _Ht::const_pointer pointer;
  typedef typename _Ht::const_pointer const_pointer;
  typedef typename _Ht::const_reference reference;
  typedef typename _Ht::const_reference const_reference;

  typedef typename _Ht::const_iterator iterator;
  typedef typename _Ht::const_iterator const_iterator;

  typedef typename _Ht::allocator_type allocator_type;

  hasher hash_funct() const { return _M_ht.hash_funct(); }
  key_equal key_eq() const { return _M_ht.key_eq(); }
  allocator_type get_allocator() const { return _M_ht.get_allocator(); }

public:
  hash_set()
    : _M_ht(100, hasher(), key_equal(), allocator_type()) {}
  explicit hash_set(size_type __n)
    : _M_ht(__n, hasher(), key_equal(), allocator_type()) {}
  hash_set(size_type __n, const hasher& __hf)
    : _M_ht(__n, __hf, key_equal(), allocator_type()) {}
  hash_set(size_type __n, const hasher& __hf, const key_equal& __eql,
           const allocator_type& __a = allocator_type())
    : _M_ht(__n, __hf, __eql, __a) {}


  template <class _InputIterator>
  hash_set(_InputIterator __f, _InputIterator __l)
    : _M_ht(100, hasher(), key_equal(), allocator_type())
    { _M_ht.insert_unique(__f, __l); }
  template <class _InputIterator>
  hash_set(_InputIterator __f, _InputIterator __l, size_type __n)
    : _M_ht(__n, hasher(), key_equal(), allocator_type())
    { _M_ht.insert_unique(__f, __l); }
  template <class _InputIterator>
  hash_set(_InputIterator __f, _InputIterator __l, size_type __n,
           const hasher& __hf)
    : _M_ht(__n, __hf, key_equal(), allocator_type())
    { _M_ht.insert_unique(__f, __l); }
  template <class _InputIterator>
  hash_set(_InputIterator __f, _InputIterator __l, size_type __n,
           const hasher& __hf, const key_equal& __eql,
           const allocator_type& __a = allocator_type())
    : _M_ht(__n, __hf, __eql, __a)
    { _M_ht.insert_unique(__f, __l); }


public:
  size_type size() const { return _M_ht.size(); }
  size_type max_size() const { return _M_ht.max_size(); }
  bool empty() const { return _M_ht.empty(); }
  void swap(hash_set& __hs) { _M_ht.swap(__hs._M_ht); }
  friend bool operator== (const hash_set&, const hash_set&);

  iterator begin() const { return _M_ht.begin(); }
  iterator end() const { return _M_ht.end(); }

public:
  pair<iterator, bool> insert(const value_type& __obj)
    {
      pair<typename _Ht::iterator, bool> __p = _M_ht.insert_unique(__obj);
      return pair<iterator,bool>(__p.first, __p.second);
    }

  template <class _InputIterator>
  void insert(_InputIterator __f, _InputIterator __l) 
    { _M_ht.insert_unique(__f,__l); }

  pair<iterator, bool> insert_noresize(const value_type& __obj)
  {
    pair<typename _Ht::iterator, bool> __p = 
      _M_ht.insert_unique_noresize(__obj);
    return pair<iterator, bool>(__p.first, __p.second);
  }

  iterator find(const key_type& __key) const { return _M_ht.find(__key); }

  size_type count(const key_type& __key) const { return _M_ht.count(__key); }
  
  pair<iterator, iterator> equal_range(const key_type& __key) const
    { return _M_ht.equal_range(__key); }

  size_type erase(const key_type& __key) {return _M_ht.erase(__key); }
  void erase(iterator __it) { _M_ht.erase(__it); }
  void erase(iterator __f, iterator __l) { _M_ht.erase(__f, __l); }
  void clear() { _M_ht.clear(); }

public:
  void resize(size_type __hint) { _M_ht.resize(__hint); }
  size_type bucket_count() const { return _M_ht.bucket_count(); }
  size_type max_bucket_count() const { return _M_ht.max_bucket_count(); }
  size_type elems_in_bucket(size_type __n) const
    { return _M_ht.elems_in_bucket(__n); }
};

template <class _Value, class _HashFcn, class _EqualKey, class _Alloc>
inline bool 
operator==(const hash_set<_Value,_HashFcn,_EqualKey,_Alloc>& __hs1,
           const hash_set<_Value,_HashFcn,_EqualKey,_Alloc>& __hs2)
{
  return __hs1._M_ht == __hs2._M_ht;
}





template <class _Value, class _HashFcn = hash<_Value>,
          class _EqualKey = equal_to<_Value>,
          class _Alloc = alloc >
class hash_multiset
{
private:
  typedef hashtable<_Value, _Value, _HashFcn, _Identity<_Value>, 
                    _EqualKey, _Alloc> _Ht;
  _Ht _M_ht;

public:
  typedef typename _Ht::key_type key_type;
  typedef typename _Ht::value_type value_type;
  typedef typename _Ht::hasher hasher;
  typedef typename _Ht::key_equal key_equal;

  typedef typename _Ht::size_type size_type;
  typedef typename _Ht::difference_type difference_type;
  typedef typename _Ht::const_pointer pointer;
  typedef typename _Ht::const_pointer const_pointer;
  typedef typename _Ht::const_reference reference;
  typedef typename _Ht::const_reference const_reference;

  typedef typename _Ht::const_iterator iterator;
  typedef typename _Ht::const_iterator const_iterator;

  typedef typename _Ht::allocator_type allocator_type;

  hasher hash_funct() const { return _M_ht.hash_funct(); }
  key_equal key_eq() const { return _M_ht.key_eq(); }
  allocator_type get_allocator() const { return _M_ht.get_allocator(); }

public:
  hash_multiset()
    : _M_ht(100, hasher(), key_equal(), allocator_type()) {}
  explicit hash_multiset(size_type __n)
    : _M_ht(__n, hasher(), key_equal(), allocator_type()) {}
  hash_multiset(size_type __n, const hasher& __hf)
    : _M_ht(__n, __hf, key_equal(), allocator_type()) {}
  hash_multiset(size_type __n, const hasher& __hf, const key_equal& __eql,
                const allocator_type& __a = allocator_type())
    : _M_ht(__n, __hf, __eql, __a) {}


  template <class _InputIterator>
  hash_multiset(_InputIterator __f, _InputIterator __l)
    : _M_ht(100, hasher(), key_equal(), allocator_type())
    { _M_ht.insert_equal(__f, __l); }
  template <class _InputIterator>
  hash_multiset(_InputIterator __f, _InputIterator __l, size_type __n)
    : _M_ht(__n, hasher(), key_equal(), allocator_type())
    { _M_ht.insert_equal(__f, __l); }
  template <class _InputIterator>
  hash_multiset(_InputIterator __f, _InputIterator __l, size_type __n,
                const hasher& __hf)
    : _M_ht(__n, __hf, key_equal(), allocator_type())
    { _M_ht.insert_equal(__f, __l); }
  template <class _InputIterator>
  hash_multiset(_InputIterator __f, _InputIterator __l, size_type __n,
                const hasher& __hf, const key_equal& __eql,
                const allocator_type& __a = allocator_type())
    : _M_ht(__n, __hf, __eql, __a)
    { _M_ht.insert_equal(__f, __l); }


public:
  size_type size() const { return _M_ht.size(); }
  size_type max_size() const { return _M_ht.max_size(); }
  bool empty() const { return _M_ht.empty(); }
  void swap(hash_multiset& hs) { _M_ht.swap(hs._M_ht); }
  friend bool operator== (const hash_multiset&,
                                               const hash_multiset&);

  iterator begin() const { return _M_ht.begin(); }
  iterator end() const { return _M_ht.end(); }

public:
  iterator insert(const value_type& __obj)
    { return _M_ht.insert_equal(__obj); }

  template <class _InputIterator>
  void insert(_InputIterator __f, _InputIterator __l) 
    { _M_ht.insert_equal(__f,__l); }

  iterator insert_noresize(const value_type& __obj)
    { return _M_ht.insert_equal_noresize(__obj); }    

  iterator find(const key_type& __key) const { return _M_ht.find(__key); }

  size_type count(const key_type& __key) const { return _M_ht.count(__key); }
  
  pair<iterator, iterator> equal_range(const key_type& __key) const
    { return _M_ht.equal_range(__key); }

  size_type erase(const key_type& __key) {return _M_ht.erase(__key); }
  void erase(iterator __it) { _M_ht.erase(__it); }
  void erase(iterator __f, iterator __l) { _M_ht.erase(__f, __l); }
  void clear() { _M_ht.clear(); }

public:
  void resize(size_type __hint) { _M_ht.resize(__hint); }
  size_type bucket_count() const { return _M_ht.bucket_count(); }
  size_type max_bucket_count() const { return _M_ht.max_bucket_count(); }
  size_type elems_in_bucket(size_type __n) const
    { return _M_ht.elems_in_bucket(__n); }
};

template <class _Val, class _HashFcn, class _EqualKey, class _Alloc>
inline bool 
operator==(const hash_multiset<_Val,_HashFcn,_EqualKey,_Alloc>& __hs1,
           const hash_multiset<_Val,_HashFcn,_EqualKey,_Alloc>& __hs2)
{
  return __hs1._M_ht == __hs2._M_ht;
}
}
#endif
sp_13230409636
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C++(STL):33---hash_set、hash_map、hash_multiset、hash_multimap源码剖析
网易搬砖选手
12-20 275
这些关联容器底层都是使用hash table实现的.一、hash_set由于hash_set底层是以hash table实现的，因此hash_set只是简单的调用hash table的...
c++ unordered_set，unordered_map中自定义哈希函数
qq_34525916的博客
04-20 3801
unordered_map定义如下： template<class Key, class Ty, class Hash = std::hash<Key>, class Pred = std::equal_to<Key>, class Alloc = std::allocator<std::pair<const Key, Ty> > > class unordered_map; > class u
hash_set c++总结（自定义类型struct、class）
06-10
hash_set c++总结（自定义类型stuct、class）。总结自定义struct、class三个案例。find函数测试，hash_set迭代器。
C++_hash_set
hengfanz的专栏
03-13 7159
SGI STL是最健壮的STL实现之一，增加了很多扩充的容器，包括hash_set、hash_map、slist（单链表）、rope（它是一个string的变种，对非常大型的字符串、字符串的快速连接和取 字串等操作进行了优化）。 一、构造函数       默认构造函数、部分后全部复制另外一个hash_set hash_set > > hs1; hs1.insert(10); h
c++哈希表hash_table的深度学习(hash_map,un和hash_set的底层实现)
最新发布
weixin_72492465的博客
06-12 1460
哈希表（Hash Table）是一种数据结构，它使用哈希函数将键（key）映射到桶（bucket）或槽（slot）中，可以直接通过相应的键值直接对数据进行访问，高效的插入，删除，查找。
C++hash_set实现
liufangping的博客
10-17 1041
运用set，为的是能够快速搜寻元素，这一点不论是rb-tree和hashtable都能够达到目的，但前者有自动排序功能而hashtable没有。hash_set使用hashtable作为底层容器，hashtable提供了所有hash_set需要的操作，hash_set不允许键值重复，使用hashtable的insert_unique来插入元素 代码实现：https://github.com/inm...
看完这篇 HashSet，跟面试官扯皮没问题了
古时的风筝
07-01 705
我是风筝，公众号「古时的风筝」，一个兼具深度与广度的程序员鼓励师，一个本打算写诗却写起了代码的田园码农！ 文章会收录在 JavaNewBee 中，更有 Java 后端知识图谱，从小白到大牛要走的路都在里面。 之前的7000 字说清楚 HashMap已经详细介绍了 HashMap 的原理和实现，本次再来说说他的同胞兄弟 HashSet，这两兄弟经常被拿出来一起说，面试的时候，也经常是两者结合着考察。难道它们两个的实现方式很类似吗，不然为什么总是放在一起比较。 实际上并不是因为它俩相似，从根本上来说，它俩本.
C++实现hash_set
世界很大我很小
10-07 2611
头文件： #include using namespace std; template class hash_set { private: hash_type array[100000]; int hash_fun(hash_type original); public: hash_set();//构造函数 void insert(hash_type value);//插入一个元素 v
C++学习之第十八天-STL无序关联式容器-unordered_set、unordered_map
weixin_49278191的博客
11-20 922
1.知识点 无序关联式容器：底层实现使用哈希表。无序关联式容器中的元素没有顺序，针对于自定义类型需要自己定义std::hash函数与std::equal_to函数1.unordered_set //1、key值是唯一的，不能重复 //2、key值是没有顺序的2.unordered_multiset //1、key值是不唯一的，可以重复 //2、key值是没有顺序的3.unordered_map //1、key值是唯一的，不能重复 //2、key值是没有...
C++ STL学习笔记十一 hash_set哈希集合容器
一个IT菜鸟的自白
10-12 898
/*  *  ************************************************************************************  *      hash_set哈希集合容器的基础说明：  **************************************************************************
C++容器之基于哈希表实现的unordered_set
yyl80的博客
05-23 627
1. 基本概念 unordered_set是无序数据集，也就是没有以特别的顺序存储数据。这个是基于哈希表实现的数据容器。哈希表本质上是一个数组，与常见的数组不同的是，哈希表中存放的值是键值对。键值对就是可以根据一个键值获取对应的一个值。而对于键值，百度百科的解释是“键值（key）是windows中注册表中的概念。键值位于注册表结构链末端，和文件系统的文件类似，包含当前计算机及应用程序执行时使用的实际配置信息和数据。键值包含几种数据类型，以适应不同环境的使用需求。”通过一个键值获取对应的一个值，这个有点类似高
hashset类的使用
09-30
这个是关于java语言的hashset集合类的一些基本用法和详解了个方法的使用
整数二分如何避免边界问题 —— AcWing789.数的范围
Marlborohi的博客
11-30 290
二分原理 整数的二分问题中最关键的是mid值的选取问题，有两种选取方式： 1） right + left >> 1; 2） right + left + 1 >> 1; 那么这两种二分方式有什么区别呢？ 以二分一个数组中的元素为例： 1） 数组中的元素是奇数个：无分别，都是选取中间元素 2） 数组中的元素是偶数个，前者的mid选取前半部分最后一个元素，后者选取后半部分第一个元素。 若是ture在右半边范围内，则用L+R >> 1 若是true在左半边范围内，则用L+R
Redis 学习笔记（四）五大基本数据类型set
weixin_41561640的博客
10-20 122
redis的基本数据类型为： string list set hash zset set数据类型（集合）值是无序的不可重复的 在redis中，set命令都以"s"开头： sadd <set> <value>... #向set中添加元素 smembers <set> #获取set中的所有元素 sismember <set> <value> #判断set中是否存在value元素 scard <se
c++ hashset的用法_C++ set用法（STL set用法）详解
weixin_28965851的博客
12-29 4500
是时候了解一下 set 容器的用法了。我们把 vector、set 和 map 容器组合在一起来创建一个示例，并且会介绍一种新的有用算法。在这个示例中，你会将学习不同学科的学生分配到一组。每个学生都必须学习指定的最小数目的学科。每个学习特定学科的学生都被保存到 set 容器中，因为一个学生只能在一门特定课程中出现一次。这个示例不会特别有效率。在本例中会大量地拷贝学生对象，这里可能无关紧要，但是如果...
c++ hashset的用法_C++中 set（集合容器）的用法
weixin_39611331的博客
12-19 1599
set集合容器：实现了红黑树(Red-Black Tree)的平衡二叉检索树的数据结构，在插入元素时，它会自动调整二叉树的排列，把该元素放到适当的位置，以确保每个子树根节点的键值大于左子树所有节点的键值，而小于右子树所有节点的键值；另外，还得确保根节点的左子树的高度与有字数的高度相等，这样，二叉树的高度最小，从而检索速度最快。要注意的是，它不会重复插入相同键值的元素，而采取忽略处理。平衡二叉检索树...
c++ hashset的用法_带你详细了解C++中的map(键值对)和set(集合)_后端开发
weixin_39963080的博客
12-19 697
strcmp在c语言中是什么意思？_后端开发strcmp在c语言中的意思是string compare的缩写，用于比较两个字符串并根据比较结果返回整数，基本形式为strcmp(str1,str2)，若【str1=str2】，则返回零，若【str1C++学习:map集合(键值对)集合(set)与映射(map)属于非线性结构容器类内部实现上面是平衡二叉树map是STL的一个关联性容器,它提供一对一的数...
C++hash_set实现 STL
生活需要深度
07-08 383
hash_set stl实现
c++ unordered_set 数据类型
08-07
C++中的unordered_set是一种关联容器，用于存储唯一的元素集合，其中元素的顺序是无序的。它是使用哈希表实现的，因此具有快速的查找和插入操作的特点。 unordered_set模板的定义如下： ```cpp template , class ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值