哈希表的封装和位图

最新推荐文章于 2024-10-16 19:08:56 发布
最新推荐文章于 2024-10-16 19:08:56 发布
阅读量1k 收藏 16
点赞数 23
分类专栏： c++ 文章标签： 散列表 数据结构 c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Suinnn/article/details/142031227
版权

文章目录

2 封装

2.1 基础框架

文章

有了前面map和set封装的经验，容易写出下面的代码

// UnorderedSet.h
#pragma once
#include "HashTable.h"
template <class K, class Hash = HashFunc<K>>
class UnorderedSet
{
	// 返回key
	struct SetKeyOfT
	{
		const K& operator()(const K& key)
		{
			return key;
		}
	};
public:
	bool insert(const K& key)
	{
		return _ht.Insert(key);
	}
private:
	HashTable<K, K, SetKeyOfT, Hash> _ht;
};

// UnorderedMap.h
#pragma once
#include "HashTable.h"
template <class K, class V,  class Hash = HashFunc<K>>
class UnorderedMap
{
	// 返回pair的first,即key
	struct MapKeyOfT
	{
		const K& operator()(const pair<K, V> &kv)
		{
			return kv.first;
		}
	};
public:
	bool insert(const pair<K, V>& kv)
	{
		return _ht.Insert(kv);
	}
	
private:
	HashTable<K, pair<K, V>, MapKeyOfT, Hash> _ht;
};

// HashTable.h
template <class T>
struct HashNode
{
	HashNode(const T& data)
		: _data(data)
		, _next(nullptr)
	{}
	HashNode* _next;
	T _data;
};
// UnorderedMap->HashTable<K, pair<K, V>>
// UnorderedSet->HashTable<K, K>
template <class K, class T, class KeyOfT , class Hash>
class HashTable
{
	typedef HashNode<T> Node;
public:
	// ...
	bool Insert(const T& data)
	{
		// 如果已经有该元素了，返回false
		if (Find(kot(data)))	return false;
		size_t sz = _table.size();
		// 负载因子设置到1
		if (_table.size() == _n)
		{
			size_t newSz = sz * 2;
			vector<Node*> newTable;
			newTable.resize(newSz, nullptr);

			for (size_t i = 0; i < sz; ++i) {
				Node* cur = _table[i];
				while (cur) {
					Node* next = cur->_next;
					size_t hashI = hf(kot(cur->_data)) % newSz;
					// 头插到新链表
					cur->_next = newTable[hashI];
					newTable[hashI] = cur;
					cur = next;
				}
				_table[i] = nullptr;
			}
			_table.swap(newTable);
		}

		size_t hashI = hf(kot(data)) % sz;
		Node* newNode = new Node(data);
		// 头插
		newNode->_next = _table[hashI];
		_table[hashI] = newNode;
		++_n;
		return true;
	}
	// ...
private: 
	vector<Node*> _table;
	size_t _n;
	Hash hf;
	KeyOfT kot;
};

其中HashTable.h中部分代码已经省略，详细见文章

2.2 迭代器(1)

写法1

// HashTable.h
template <class T>
struct __HTIterator
{
	typedef HashNode<T> Node;
	typedef __HTIterator<T> Self;
	Node* _node;
	vector<Node*>& _table;	// 方便找下一个桶
	size_t _hashI;		// 当前找到哪个桶了

	__HTIterator(Node* node, vector<Node*>& table, size_t hashI)
		: _node(node)
		, _table(table)
		, _hashI(hashI)
	{}

	Self& operator++()
	{
		if (_node->_next) {
			// 当前桶还有节点，走到下一个节点
			_node = _node->_next;
		}
		else {
			// 当前桶没有节点了，去找下一个桶
			++_hashI;
			while (_hashI < _table.size()) {
				if (_table[_hashI] != nullptr) {
					// 找到了非空节点
					_node = _table[_hashI];
					break;
				}
				++_hashI;
			}
			// 没有下一个有节点的桶了
			if (_hashI == _table.size()) {
				_node = nullptr;	// 让nullptr充当end()
			}
		}
		return *this;
	}

	bool operator!=(const Self& s)
	{
		return _node != s._node;
	}

	T& operator*()
	{
		return _node->_data;
	}

	T* operator->()
	{
		return &(_node->_data);
	}
};

template <class K, class T, class KeyOfT , class Hash = HashFunc<K>>
class HashTable
{
    // ...
    typedef __HTIterator<T> Iterator;
	Iterator begin()
    {
        // 找到第一个有存值的桶，传给迭代器
        for (size_t i = 0; i < _table.size(); i++) {
            if (_table[i] != nullptr) {
                return Iterator(_table[i], _table, i);
            }
        }
        // 找到最后还没有找到，证明是空哈希表
        return end();
    }
    
    Iterator end()
    {
        return Iterator(nullptr, _table, -1);
    }
  	// ...
}

2.3 迭代器(2)

// 因为后面的__HTIterator使用了HashTable这个类，向上找找不到，所以需要前置声明
template <class K, class T, class KeyOfT, class Hash>
class HashTable;

template <class K, class T, class KeyOfT, class Hash>
struct __HTIterator
{
	typedef HashNode<T> Node;
	typedef __HTIterator<K, T, KeyOfT, Hash> Self;
	Node* _node;
	HashTable<K, T, KeyOfT, Hash>* _ht;	// 方便找下一个桶
	size_t _hashI;		// 当前找到哪个桶了

	__HTIterator(Node* node, HashTable<K, T, KeyOfT, Hash>* ht, size_t hashI)
		: _node(node)
		, _ht(ht)
		, _hashI(hashI)
	{}

	Self& operator++()
	{
		if (_node->_next) {
			// 当前桶还有节点，走到下一个节点
			_node = _node->_next;
		}
		else {
			// 当前桶没有节点了，去找下一个桶
			++_hashI;
			while (_hashI < _ht->_table.size()) {
				if (_ht->_table[_hashI] != nullptr) {
					// 找到了非空节点
					_node = _ht->_table[_hashI];
					break;
				}
				++_hashI;
			}
			// 没有下一个有节点的桶了
			if (_hashI == _ht->_table.size()) {
				_node = nullptr;	// 让nullptr充当end()
			}
		}
		return *this;
	}

	// ...
};

template <class K, class T, class KeyOfT, class Hash>
class HashTable
{
	typedef HashNode<T> Node;
	template <class K, class T, class KeyOfT, class Hash>
	friend struct __HTIterator;		// 让__HTIterator成为HashTable的友元，因为用到了_table这个私有属性
public:
    
	typedef __HTIterator<K, T, KeyOfT, Hash> Iterator;
    Iterator begin()
    {
        // 找到第一个有存值的桶，传给迭代器
        for (size_t i = 0; i < _table.size(); i++) {
            if (_table[i] != nullptr) {
                return Iterator(_table[i], this, i);
            }
        }
        // 找到最后还没有找到，证明是空哈希表
        return end();
    }

    Iterator end()
    {
        return Iterator(nullptr, this, -1);
    }
    // ...
}

const迭代器不再实现，太复杂了。

3. 位图

概念：所谓位图，就是用每一位来存放某种状态，适用于海量数据，数据无重复的场景。通常是用来判断某个数据存不存在的。

3.1 问题引入

给40亿个不重复的无符号整数，没排过序。给一个无符号整数，如何快速判断一个数是否在这40亿个数中。

  1. 遍历，时间复杂度O(N)

  2. 排序(O(NlogN))，利用二分查找: logN

  3. 数据是否在给定的整形数据中，结果是在或者不在，刚好是两种状态，那么可以使用一个二进制比特位来代表数据是否存在的信息，如果二进制比特位为1，代表存在，为0代表不存在。比如：

​ image-20240908131159204

可以计算一下，40亿个数，需要开2^32bit，即512MB

3.2 左移和右移？

image-20240908154458368

vs是以小端字节序存储的，左移指的是像高地址移动，右移是指向低地址移动，并不是按移动的方向定义的

执行完i = 1

image-20240908155207271

执行完i <<= 8

image-20240908155231047

image-20240908155547251

3.3 位图的实现

// N表示需要多少bit位
template<size_t N>
class MyBitset
{
public:
	MyBitset()
	{
		_bits.resize(N / 32 + 1, 0);
	}

	/*把x映射的位置1
	* x在数组的第几个整形呢？		i = x / 32
	* x在这个整形的第几个位呢？   j = x % 32*/ 
	void set(size_t x) 
	{
		size_t i = x / 32;
		size_t j = x % 32;
		// 或等上1<<j
		_bits[i] |= (1 << j);
	}

	// 把x映射的位置0
	void reset(size_t x)
	{
		size_t i = x / 32;
		size_t j = x % 32;
		// 与等上~(1<<j)
		_bits[i] &= (~(1 << j));
	}

	// 检查x所在的bit是0还是1
	bool test(size_t x)
	{
		size_t i = x / 32;
		size_t j = x % 32;
		// 与上1
		return _bits[i] & (1 << j);
	}
private:
	vector<size_t> _bits;
};

image-20240908162435739

上面的3.1的问题，我们可以开一个bitset来解决

// solution 1
MyBitset<0xffffffff> bs;
// solution 2
MyBitset<-1> bs2;

3.4 位图的题目

  1. 给定100亿个整数，设计算法找到只出现一次的整数？

使用两个bitset，00表示出现0次，01表示出现1次，10表示出现2次或者2次以上

template<size_t N>
class TwoBitset
{
public:
	/*
	* 00->01
	* 01->10
	* 10->same
	*/
	void set(size_t x)
	{
		if (!_bs1.test(x) and !_bs2.test(x)) {
			_bs2.set(x);
		}
		else if (!_bs1.test(x) and _bs2.test(x)) {
			_bs1.set(x);
			_bs2.reset(x);
		}
	}

	/* 打印出现一次的数字 */
	void PrintOnce()
	{
		for (size_t i = 0; i < N; i++) {
			if (!_bs1.test(i) and _bs2.test(i))
				cout << i << ' ';
		}
		cout << endl;
	}

private: 
	MyBitset<N> _bs1;
	MyBitset<N> _bs2;
};
  1. 给两个文件，分别有100亿个整数，我们只有1G内存，如何找到两个文件交集？

与上面类似：将这些整数各自映射到一个位图，一个值在两个位图都存在，则是交集

  1. 位图应用变形：1个文件有100亿个int，1G内存，设计算法找到出现次数不超过2次的所有整数

也是一样，两个位图，00表示出现0次，01表示出现1次，10表示出现2次，11表示出现3次及以上

3.5 位图的应用

  1. 快速查找某个数据是否在一个集合中
  2. 排序 + 去重
  3. 求两个集合的交集、并集等
  4. 操作系统中磁盘块标记
冰红茶兑滴水
关注
专栏目录
哈希的应用——位图
m0_70980326的博客
09-05 1152
哈希的应用——位图详解
C++ 哈希的应用【位图】
北 海的博客
07-25 5608
位图（bitset）是一种特殊的数据结构，仅仅依靠01表示当前位置是否有数据存在，常用于对查找速度和存储空间有着高要求的场景中，除此之外，位图还可以配合宏定义，实现同时传递多个参数，比如系统调用open，其中的参数2（打开方式）就是一个简单的位图结构
C++：哈希表和unordered系列容器的封装
weixin_51142926的博客
05-06 2834
在C++11中，STL又提供了4个unordered系列的关联式容器，这四个容器与红黑树结构的关联式容器使用方式基本类似，只是其底层结构不同（哈希表）
哈希表——位图
qq_67693066的博客
02-18 874
哈希表——位图
【C++】哈希应用之位图
Aron的博客
06-06 1238
位图（bitset）是一种特殊的数据结构，仅仅依靠01表示当前位置是否有数据存在，常用于对查找速度和存储空间有着高要求的场景中，除此之外，位图还可以配合宏定义，实现同时传递多个参数，比如系统调用open，其中的参数2（打开方式）就是一个简单的位图结构位图是一种十分特殊的数据结构，其主要依靠0和1表征状态，结合哈希的映射思想，即保证了速度，又保证了空间位图速度极快O(1)节省空间 使用粒度最细的比特位位图只能映射整型对于浮点符、字符串等数据无法做到很好的映射位图快速查找某个数据是否在一个集合中。
C++:哈希表和unordered系列容器
dao_shadow的博客
08-24 652
在C++98中，STL提供了底层为红黑树的一系列关联式容器，查询效率为log2N，即便在最差情况下也仅需要比较红黑树的高度次，所以当树中的节点非常多时，查询效率也不是很理想。它通过一个计算键值的函数（散列函数）来将所查询的数据映射到哈希表中的一个位置来查找该位置的内容，从而达到快速查找的目的。3. 在内部,unordered_map没有对<key, value>按照任何特定的顺序排序, 为了能在常数范围内找到key所对应的value，unordered_map将相同哈希值的键值对放在相同的哈希桶中。
【哈希】关于哈希表和哈希函数的理解与应用
Adelaide_Guo的博客
08-05 1268
0.概述 哈希，或者说散列，在教科书上写的都比较详细，通常包括的内容有散列的方法，散列冲突的解决等。本文暂且不表这些基础知识，更多的重点在于哈希的一些应用和题目，对于哈希表、哈希函数从来没有学习过或者已经遗忘大部分的同学，建议先去阅读相关内容，否则本文不会成为一篇值得阅读的内容。 1.哈希的函数的定义以及性质 之所以要介绍这一小节，主要是几乎所有的哈希函数的应用都离不开定义和性质，也正是因为哈希函数拥有这些性质才在各种场景发挥着优秀的性能。 定义： ，其中输入域为无穷，值域为有限域。 哈希函数的定
哈希(解决哈希冲突，封装map/set，哈希的应用{位图/布隆过滤器})
Morn_Star_Oliver的博客
07-11 628
C++哈希的内容
哈希表实现[很详细!]
2301_79602614的博客
04-22 945
int hash;//哈希码Object key;//键//值Entry next;//数组存链表头指针即可//选择2^nint size=0;//元素个数。
C++ 哈希
m0_61548909的博客
08-27 2870
在 C++98 中， STL 提供了底层为红黑树结构的一系列关联式容器，在查询时效率可达到 $log_2N$，即最差情况下需要比较红黑树的高度次，当树中的节点非常多时，查询效率也不理想。最好的查询是，进行很少的比较次数就能够将元素找到，因此在C++11 中， STL 又提供了 4 个unordered系列的关联式容器，这四个容器与红黑树结构的关联式容器使用方式基本类似，只是其底层结构不同，本文中只对unordered_map 和 unordered_set 进行介绍，unordered_multimap和
【探索性能瓶颈】：哈希表局限性分析，如何突破性能限制
本章将带你深入理解哈希表的核心概念、基础原理以及其在数据存储和检索中的关键作用。 ## 1.1 哈希表的定义与结构 哈希表是一种通过哈希函数将键(key)映射到存储位置的数据结构，以便实现快速的数据查找。它由一...
C++哈希
zhao19971014的博客
11-14 904
哈希
哈希对于大数据的处理
w1724556613的博客
06-06 519
哈希对于大数据的处理一般借助位图和布隆过滤器。首先我们先对于这两种数据结构进行应用。 第一:大数据整数，找只出现一次或者两次或者三次的小次数重复的数。如何寻找？ 我们借助于map统计次数的思想，并加以对位图进行改装，使用两个位图进行操作。底层封装两个位图，一个位表示存在，另一个位标识是否出现两次或者以上。比如01表示一次，10表示两次以上，而更多的有限次就可以使用这种方式来表示，其本质的思路，还是利用较小的空间表示更多的状态，还是一种抓特性特点的处理数据方式。 #include "bitset.h" usi
数据结构与算法：高级数据结构与实际应用
weidl001的博客
10-16 924
本章介绍了跳表、Trie树、B树与 B+树等高级数据结构，以及它们在实际系统中的应用。这些数据结构在提高查找效率、优化存储和加速特定任务方面具有不可替代的作用。通过深入理解这些结构及其特性，我们能够选择最合适的数据结构来应对复杂的实际问题。在下一章中，我们将深入讨论并查集与线段树的高级应用，以及它们在图论和范围查询中的重要作用。
数据结构常考基础代码题-顺序表有序插入
qq_52291558的博客
10-16 389
根据题目中的“顺序表递增有序”，我们需要定义一个顺序表结构体，用于存储元素和顺序表的相关信息。
数据结构（排序）
m0_74859128的博客
10-10 796
一、定义排序是将一组数据元素按照某个关键字的值递增或递减的次序重新排列的过程。这个关键字是数据元素中的某个数据项，通过比较关键字的大小来确定数据元素的先后顺序。二、目的便于查找例如在一个有序数组中查找某个元素，使用二分查找等算法效率更高。如果数据是无序的，可能只能进行顺序查找，时间复杂度较高。数据呈现的有序性在很多应用场景中，如成绩排名、文件按时间顺序排列等，需要数据以有序的形式展示，以便于人们理解和分析。三、分类内部排序和外部排序内部排序指待排序的数据元素全部存放在计算机内存中的排序算法。
数据结构常考基础代码题-数组倒置
最新发布
qq_52291558的博客
10-16 348
根据题目中的“将数组中的元素顺序反转”，我们需要实现一个函数Reverse，用于反转数组中从start到end的元素。// 函数用于反转数组A中从start到end的元素int temp;// 使用while循环进行元素交换，直到start和end相遇或交叉// 保存A[start]的值// 将A[end]的值赋给A[start]// 将temp（原A[start]的值）赋给A[end]start++;// 移动start指针end--;// 移动end指针。
数据结构-顺序表
m0_60633015的博客
10-13 282
静态顺序表：使用定长数组存储元素.缺点是 动态顺序表：使用动态开辟的数组存储元素.依次存储数据元素的线性结构，一般情况下采用数组存储。在数组上完成数据的增删查改。顺序表: 顺序表是用一段。顺序表的指定位置插入。顺序表指定位置的删除。
嵌入式数据结构中树与查找方法实现
嵌入式技术开发
10-13 188
Tree）是nn≥0）个节点的有限集合T，它满足两个条件有且仅有一个特定的称为根Root的节点其余的节点可以分为mm≥0）个互不相交的有限集合T1T2……Tm，其中每一个集合又是一棵树，并称为其根的子树（Subtree一个节点的子树的个数称为该节点的度数一棵树的度数是指该树中节点的最大度数。度数为零的节点称为树叶或终端节点，度数不为零的节点称为分支节点，除根节点外的分支节点称为内部节点。一个节点的子树之根节点称为该节点的子节点。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值