哈希思想及其常见应用

于 2024-04-22 20:38:04 发布
阅读量794 收藏 22
点赞数 17
文章标签： 哈希算法 散列表 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_74494481/article/details/137844836
版权

哈希


哈希或者散列是一种思想：即通过某个转换函数在某两种数据之间建立映射关系，利用这种思想建立的数据结构都可以看作是哈希结构，这个转换函数就被称为哈希函数。
这种思想在计算机中的一大应用就是哈希表：利用哈希函数建立数据的关键字和数据存储位置之间的映射关系，这样就可以快速地对某个数据进行查找。一般是先将数据关键字输入到哈希函数中得到一个哈希函数值，然后在哈希表中把数据存放到以该哈希函数值为下标的位置即可。

常见整型数据的哈希函数

由于我们不可能保证我们创建的哈希函数是单射的，这就意味着不同的关键字通过该哈希函数得到的函数值可能会相同，这会导致不同的关键字找到了同一个存储地址，这显然不是我们希望看到的，因此我们需要合理地设计哈希函数，尽量减少冲突。
哈希函数设计原则：
1.哈希函数定义域必须包括需要存储的数据的所有关键字
2.哈希函数计算出的地址应均匀的分布在存储空间中
3.哈希函数应尽可能简单

常见的整型数据的哈希函数如下（假设关键字的数据类型是size_t）：

1.直接定址法–(常用)
直接取关键字的某个线性函数作为散列地址：Hash(Key) = A*Key+B
这种办法简单且得到的地址均匀，但只适用于关键字分布较为集中但不重叠的情况。

2.除余留数法–(常用)
假设散列表允许的地址苏为m，取一个不大于m但接近m的数（一般取质数）p作为取余除数，即Hash(Key) = Key%p。

3.平方取中法–(了解)
假设关键字为1234，对它平方就是1522756，抽取中间的3位227作为哈希地址；再比如关键字为4321，对它平方就是18671041，抽取中间的3位671(或710)作为哈希地址，平方取中法比较适合：不知道关键字的分布，而位数又不是很大的情况。

4.折叠法–(了解)
折叠法是将关键字从左到右分割成位数相等的几部分(最后一部分位数可以短些)，然后将这几部分叠加求和，并按散列表表长，取后几位作为散列地址。折叠法适合事先不需要知道关键字的分布，关键字位数比较多的情况。

5.随机数法–(了解)
选择一个随机函数，取关键字的随机函数值为它的哈希地址，即H(key) = random(key),其中random为随机数函数。通常应用于关键字长度不等时采用此法。

6.数学分析法–(了解)
设有n个d位数，每一位可能有r种不同的符号，这r种不同的符号在各位上出现的频率不一定相同，可能在某些位上分布比较均匀，每种符号出现的机会均等，在某些位上分布不均匀只有某几种符号经常出现。可根据散列表的大小，选择其中各种符号分布均匀的若干位作为散列地址。例如：假设要存储某家公司员工登记表，如果用手机号作为关键字，那么极有可能前7位都是 相同的，那么我们可以选择后面的四位作为散列地址，如果这样的抽取工作还容易出现 冲突，还可以对抽取出来的数字进行反转(如1234改成4321)、右环位移(如1234改成4123)、左环移位、前两数与后两数叠加(如1234改成12+34=46)等方法。数字分析法通常适合处理关键字位数比较大的情况，如果事先知道关键字的分布且关键字的若干位分布较均匀的情况。

由于数据的关键字的数据类型不一定是size_t，我们还需要将数据的关键字映射到size_t上：即先用某个哈希函数将关键字key的数据类型映射到size_t上得到s_key，接着再用整型数据的哈希函数将s_key映射成哈希表的位置。
例如倘若关键字为字符串类型，我们常采用的哈希函数为：逐个相加每个字符的ASCAII码，并在每次相加后将结果乘以一个权值（一般取131），这样就将string类型映射到size_t上了。字符串Hash函数

需要注意的是，哈希函数设计的越精妙，产生哈希冲突的可能性就越低，但是无法避免哈希冲突。

哈希冲突的解决

无论哈希函数设计的多么巧妙，我们也无法保证其不会产生哈希冲突，一旦出现哈希冲突，就需要进行补救措施，常见的哈希冲突的解决办法有2种：闭散列和开散列。
这里补充一下负载因子的概念，哈希表的大小一般会大于数据个数，数据个数和哈希表的大小的比值被称为负载因子，为了减少哈希冲突但又不浪费空间，一般负载因子的大小在0.7左右比较合适。

闭散列

闭散列也称为开放地址法，由于我们不会让哈希表被填满，因此当哈希冲突产生时，表中一定还有空间没有被使用，我们只需要按照某种探测方法去寻找这些没有被使用的空间，一旦寻找到某个未被使用的空间就将数据存放到该空间中即可。在进行数据查找时，我们只需要再按照探测空间的方法去寻址，直到遇到未被使用的空间为止，如果该数据存在就一定可以找到。
常见的空间探测方法有2种：

1.线性探测
将哈希函数值作为下标在哈希表中找到对应位置，如果该位置未被使用，直接在该位置存放数据即可，如果该位置被使用了，从该位置开始，逐个位置往后探测，如果到了表尾，则跳到表头继续往后探测，直至遇到没有被使用的位置为止。这种方法实现简单，但当发生哈希冲突时其占用了其他哈希函数值对应位置的空间，引发“恶性循环”，导致某些关键码查找时需要多次寻址，降低数据查找效率。

2.二次探测
将哈希函数值作为下标在哈希表中找到对应位置，如果该位置未被使用，直接在该位置存放数据即可，如果该位置被使用了，其寻找下一个空位置的方法为： H i H_i Hi​ = ( H 0 H_0 H0​ + i 2 i^2 i2 )% m, 或者： H i H_i Hi​ = ( H 0 H_0 H0​ - i 2 i^2 i2 )% m。其中：i =
1,2,3…， H 0 H_0 H0​是通过哈希函数Hash(x)对元素的关键码 key 进行计算得到哈希函数值，m是表的大小。
研究表明：当表的长度为质数且表装载因子a不超过0.5时，新的表项一定能够插入，而且任何一个位置都不会被探查两次。因此只要表中有一半的空位置，就不会存在表满的问题。在搜索时可以不考虑表装满的情况，但在插入时必须确保表的装载因子a不超过0.5，如果超出必须考虑增容。
二次探测只是在一定程度上让查找效率不降低得那么明显，在我们看来其效果依旧不够理想。
对于闭散列，还有其他的空间探测方法，这里不再展示，由上我们也可以看出，闭散列不仅空间利用率低，还会降低查找效率。

下面利用除余留数法作为哈希函数，采用线性探测的方法实现哈希表的查找、插入、删除功能。

#include<iostream>
#include<string>
#include<vector>
#include<utility>

using namespace std;

// 注意：实现的哈希表中元素唯一，即key相同的元素不再进行插入

//用于标记哈希表中位置的状态
enum State { EMPTY, EXIST, DELETE };

template<class K, class V>
class HashTable
{
	struct Elem
	{
		pair<K, V> _val;
		State _state;
	};

public:
	HashTable(size_t capacity = 3)
		: _ht(capacity),
		_size(0),
		_capacity(capacity)
	{
		for (size_t i = 0; i < capacity; ++i)
			_ht[i]._state = EMPTY;
	}

	// 插入
	bool Insert(const pair<K, V>& val)
	{
		if ((float)(_size+1) / _capacity >= 0.7)
		{
			Expand_Capacity();
		}

		size_t pos = HashFunction(val.first);
		while (1)
		{
			if (EXIST != _ht[pos]._state)
			{
				_ht[pos]._val = val;
				_ht[pos]._state = EXIST;
				++_size;
				return true;
			}
			else
			{
				if (_ht[pos]._val.first == val.first)
				{
					return false;
				}
				if (++pos == _capacity)
				{
					pos = 0;
				}
			}
		}

		return false;
	}

	// 查找
	size_t Find(const K& key)
	{
		size_t pos = HashFunction(key);
		while (EMPTY != _ht[pos]._state)
		{
			if (EXIST== _ht[pos]._state && key == _ht[pos]._val.first)
			{
				return pos;
			}
			if (++pos == _capacity)
			{
				pos = 0;
			}
		}

		return -1;
	}

	// 删除
	bool Erase(const K& key)
	{
		size_t pos = Find(key);
		if (-1 != pos)
		{
			--_size;
			_ht[pos]._state = DELETE;
			return true;
		}

		return false;
	}

	void Swap(HashTable<K, V>&ht)
	{
		swap(_size, ht._size);
		swap(_capacity, ht._capacity);
		_ht.swap(ht._ht);
	}

private:

	//整型关键字的哈希函数
	template<class K>
	size_t HashFunction(const K & key) const
	{
		return key % _ht.capacity();
	}

	//string类型关键字的哈希函数
	template<>
	size_t HashFunction<string>(const string & key) const
	{
		size_t ret = 0;
		size_t i = 0;
		while (i < key.size())
		{
			ret += key[i];
			ret *= 131;
			++i;
		}

		return ret %_capacity;
	}

	void Expand_Capacity()
	{
		HashTable<K, V> ht(2 * _capacity);
		size_t i = 0;
		while (i < _capacity)
		{
			if (EXIST == _ht[i]._state)
			{
				ht.Insert(_ht[i]._val);
			}
			++i;
		}

		this->Swap(ht);
	}

private:
	vector<Elem> _ht;
	size_t _size;
	size_t _capacity;
};

开散列

开散列又叫链地址法，我们在哈希表中不直接存放数据，而是存放一个链表的头结点。首先对关键码集合用散列函数计算散列地址，具有相同地址的关键码归于同一子集合，每一个子集合称为一个桶，各个桶中的元素通过一个单链表链接起来，各链表的头结点存储在哈希表中。如果出现一些桶元素个数过多（一般是当元素个数大于8时），那么在哈希表中这些位置就不挂链表，而是挂红黑树。
为了减少哈希冲突，我们一般选择在哈希桶个数等于元素个数时进行扩容，且一般选择的容量是前一次容量的接近2倍的素数。

使用开散列需要每个数据增设链接指针，似乎增加了存储开销。事实上：由于闭散列必须保持大量的空闲空间以确保搜索效率，如二次探查法要求装载因子在0.5左右，而表项所占空间又比指针大的多，所以使用开散列反而比闭散列节省存储空间，且当哈希表下面不挂链表而是挂一些查找效率极高的数据结构如红黑树时，那么由于哈希冲突带来的查找效率下降的负面影响就会大大降低。

下面利用除余留数法作为哈希函数，采用开散列挂链表的方法实现哈希表的查找、插入、删除功能。

#include<iostream>
#include<utility>
#include<vector>
#include<string>

using namespace std;

//用于将整型数据哈希映射到整型上面，实现这个哈希函数是为了接口统一性
template<class K>
class HashFunc
{
public:
	size_t operator()(const K& val)
	{
		return val;
	}
};

//用于将string类型数据映射到size_t类型上
template<>
class HashFunc<string>
{
public:
	size_t operator()(const string& s)
	{
		size_t weight = 131; // 31 131 1313 13131 131313
		size_t hash = 0;
		int i = 0;
		while (i<s.size())
		{
			hash = hash * weight + s[i++];
		}

		return hash;
	}
};

//元素节点
template<class K,class V>
struct HashBucketNode
{
	HashBucketNode(const pair<K,V>& data)
		: _next(nullptr)
		, _data(data)
	{}
	HashBucketNode<K,V>* _next;
	pair<K,V> _data;
};

template<class K,class V, class HF = HashFunc<K>>
class HashTable
{
	typedef HashBucketNode<K,V> Node;
	typedef Node* pNode;
	typedef HashTable<K,V, HF> Self;

public:
	HashTable(size_t capacity=0)
		: _table(GetNextPrime(capacity))
		, _size(0)
	{}

	~HashTable()
	{
		Clear();
	}

	// 插入
	bool Insert(const K& key,const V& val)
	{
		if (Size() == BucketCount())
		{
			ExpandCapacity();
		}

		size_t pos = HashFunction(key);
		pNode newpNode = new Node(pair<K,V>(key,val));
		if (nullptr == _table[pos])
		{
			++_size;
			_table[pos] = newpNode;
			return true;
		}
		pNode cur = _table[pos];
		while (cur->_next)
		{
			if (cur->_data.first == key)
			{
				return false;
			}
			cur = cur->_next;
		}
		if (cur->_data.first == key)
		{
			return false;
		}
		cur->_next = newpNode;
		++_size;

		return true;
	}

	// 删除
	bool Erase(const K& key)
	{
		size_t pos = HashFunction(key);
		pNode cur = _table[pos];
		pNode pre = nullptr;
		while (cur)
		{
			if (cur->_data.first == key)
			{
				if (pre)
				{
					pre->_next = cur->_next;
				}
				else
				{
					_table[pos] = nullptr;
				}
				--_size;
				delete cur;
				return true;
			}
			pre = cur;
			cur = cur->_next;
		}

		return false;
	}

	//查找
	Node* Find(const K& key)
	{
		size_t pos = HashFunction(key);
		pNode cur = _table[pos];
		while (cur)
		{
			if (cur->_data.first == key)
			{
				return cur;
			}
			cur = cur->_next;
		}

		return nullptr;
	}

	size_t Size()const
	{
		return _size;
	}

	size_t BucketCount()const
	{
		return _table.capacity();
	}

	void Clear()
	{
		int i = 0;
		while (i < _table.size())
		{
			pNode cur = _table[i];
			while (cur)
			{
				pNode tmp = cur->_next;
				delete cur;
				cur = tmp;
			}
			_table[i] = nullptr;
			++i;
		}
	}
	
	void Swap(Self& ht)
	{
		_table.swap(ht._table);
		std::swap(_size, ht._size);
	}

private:
	void ExpandCapacity()
	{
		size_t capacity = GetNextPrime(BucketCount());
		HashTable<K, V, HF> ht(capacity-1);
		int i = 0;
		while (i < BucketCount())
		{
			pNode cur = _table[i++];
			while (cur)
			{
				ht.Insert(cur->_data.first, cur->_data.second);
				cur = cur->_next;
			}
		}
		Swap(ht);

	}

	size_t HashFunction(const K& key)
	{
		return HF()(key) % _table.size();
	}

	size_t GetNextPrime(size_t capacity)
	{
		int i = 0;
		while (i < _prime_table.size())
		{
			if (capacity < _prime_table[i])
			{
				return _prime_table[i];
			}
			++i;
		}

		return -1;
	}

private:
	vector<pNode> _table;
	size_t _size;      // 哈希表中有效元素的个数
	static  vector<size_t> _prime_table;//素数表
};

//素数表，可以根据需求开得很大
template<class K, class V, class HF>
vector<size_t> HashTable<K, V, HF>::_prime_table = { 5, 11, 23, 47, 97, 199, 397, 797 };

哈希的应用

哈希思想的应用除了哈希表外，还有位图、布隆过滤器、基数树等。

位图

位图就是用一个比特位存放某种状态，适用于海量数据且数据不重复的场景，数据类型只能为整型。其通常有以下应用：
1.快速查找某个数据是否在某个集合中
2.对数据进行排序和去重
3.求两个集合的交集、并集等
4.操作系统中磁盘块标记

C++也提供了位图容器：bitset
为了简便，假设数据类型为无符号整型，模拟位图：

#include<iostream>
#include<vector>

using namespace std;

template<size_t N>
class Bit_Map
{
public:
	Bit_Map()
	{
		_bitmap.resize(N / 8 + 1, 0);
	}

	//将pos位置1
	void Set(size_t pos)
	{
		char c = 1;
		size_t tmp1 = pos / 8;
		size_t tmp2 = 7-pos % 8;
		_bitmap[tmp1] = _bitmap[tmp1] | (c << tmp2);
	}

	//将pos位置0
	void Reset(size_t pos)
	{
		char c = 1;
		size_t tmp1 = pos / 8;
		size_t tmp2 = 7 - pos % 8;
		_bitmap[tmp1] = _bitmap[tmp1] & (~(c << tmp2));
	}

	//查看数据num是否存在
	bool Test(size_t num)
	{
		char c = 1;
		size_t tmp1 = num / 8;
		size_t tmp2 = 7 - num % 8;
		return _bitmap[tmp1] & (c << tmp2);
	}
private:
	vector<char> _bitmap;
};

如果数据有多种状态，可以给每个数据分配多个比特位，直至可以标记这些状态为止。

位图面试题：

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

思路：
由于数据的状态有3种：
①出现0次
②出现1次
③出现1次以上
因此我们需要2个比特位标记数据的状态，由于整型数据范围有限，可以使用两个比特位位数大小都为整型数据最大范围的位图，两个位图对应位置的比特位合起来就是这个位置的数据的状态。所以我们需要遍历一遍这100亿个数据将其状态标记到位图中，再遍历一遍位图即可找到只出现一次的数据。

  1. 给两个文件，分别有100亿个int型整数，我们只有1G内存，如何找到两个文件交集？

思路：1G内存有10亿多个字节，即80多亿个比特位，意味着1G内存可以标记80亿个不同的数据的2种状态，int型整数只有42多亿和不重复数值，因此可以在内存中开一个42多亿个比特位大小的位图，读取第一的文件数据，将其状态标记到位图中，再读取第二个文件，将第二个文件的数据也映射到位图中，如果该位置已被标记为存在，则这个数据属于两个文件的交集，同时为了避免数据重复，需要将该位置标记成不存在。

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

思路：显然我们需要2个比特位标记数据的4种状态
①出现0次
②出现1次
③出现2次
④出现2次以上
1G内存刚好可以存放2个大小为42多亿个比特位大小位图，与1类似，我们需要遍历一遍这100亿个数据将其状态标记到位图中，再遍历一遍位图即可找到出现次数不超过2次的数据。

布隆过滤器

布隆过滤器是一种概率型数据结构，用于确定某个数据一定不存在或者可能存在，其进行插入和查询十分高效。其通过使用多个哈希函数将一个数据映射到位图结构中的多个位置上，我们进行查询数据是否存在时只需将数据输入各个哈希函数得到对应的输出值，然后再到位图对应位置查找就可以了。尽管在位图中显示了所有哈希函数的输出值都存在，但由于哈希冲突的存在，我们依然不能确定该数据是否存在，但当某个哈希函数的输出值在位图中显示不存在时，我们一定可以确定这个数据不存在。因此布隆过滤器存在误报率，我们使用的哈希函数越多，那么该数据在位图中映射的位置越多，误报率就越低，这也意味着位图需要开更大的空间，其长度一般为L=K*N*ln2，其中L为布隆过滤器长度，K为哈希函数个数，N为数据个数。
布隆过滤器在实际中的应用主要是起到数据过滤作用，例如当用户想要大量查询某些数据在不在时，如果直接到底层数据库进行查找，由于数据库查询比较缓慢，这种查询方式的效率较低；但如果我们先用布隆过滤器对数据先简单过滤一下，倘若布隆过滤器显示该数据不在，那么该数据一定不在，倘若隆过滤器显示该数据存在，我们再到底层数据库去查询该数据是否存在，那么查询效率将会有很大的改善。

template<size_t N>
class Bit_Map
{
public:
	Bit_Map()
	{
		_bitmap.resize(N / 8 + 1, 0);
	}

	//将pos位置1
	bool Set(size_t pos)
	{
		if (pos > N)
		{
			return false;
		}
		char c = 1;
		size_t tmp1 = pos / 8;
		size_t tmp2 = 7 - pos % 8;
		_bitmap[tmp1] = _bitmap[tmp1] | (c << tmp2);
		return true;
	}

	//将pos位置0
	bool Reset(size_t pos) const
	{
		if (pos > N)
		{
			return false;
		}
		char c = 1;
		size_t tmp1 = pos / 8;
		size_t tmp2 = 7 - pos % 8;
		_bitmap[tmp1] = _bitmap[tmp1] & (~(c << tmp2));

		return true;
	}

	//查看数据num是否存在
	bool Test(size_t num)
	{
		char c = 1;
		size_t tmp1 = num / 8;
		size_t tmp2 = 7 - num % 8;
		return _bitmap[tmp1] & (c << tmp2);
	}
private:
	vector<char> _bitmap;
};

//假设数据类型为string，用3个哈希函数将数据映射到位图上
template<size_t N>
class Bloom_Filter
{
public:
	bool Insert(const string& s) 
	{
		size_t pos1 = HashFun(HashFunction1(s));
		size_t pos2 = HashFun(HashFunction2(s));
		size_t pos3 = HashFun(HashFunction3(s));
		return _bt.Set(pos1) && _bt.Set(pos2) && _bt.Set(pos3);
	}

	bool Find(const string& s)
	{
		size_t pos1 = HashFun(HashFunction1(s));
		size_t pos2 = HashFun(HashFunction2(s));
		size_t pos3 = HashFun(HashFunction3(s));

		return _bt.Test(pos1) && _bt.Test(pos2) && _bt.Test(pos3);
	}
private:
	//将整型数据映射到位图上
	size_t HashFun(size_t num) 
	{
		return num % (5*N);
	}

	//将string型数据映射到整型上

	size_t HashFunction1(const string& s)
	{
		size_t weight = 131; 
		size_t hash = 0;
		int i = 0;
		while (i < s.size())
		{
			hash = hash * weight + s[i++];
		}

		return hash;
	}

	size_t HashFunction2(const string& s)
	{
		size_t hash = 0;
		int i;

		for (i = 0;i<s.size(); i++)
		{
			if ((i & 1) == 0)
			{
				hash ^= ((hash << 7) ^ s[i] ^ (hash >> 3));
			}
			else
			{
				hash ^= (~((hash << 11) ^ s[i] ^ (hash >> 5)));
			}
		}

		return hash;
	}

	size_t HashFunction3(const string& s)
	{
		size_t hash = 5381;
		int i = 0;
		while (i<s.size())
		{
			hash += (hash << 5) + s[i++];
		}

		return hash;
	}

	Bit_Map<3*N> _bt;
};

布隆过滤器不能直接支持删除工作，因为不同元素在多个哈希函数计算出的比特位上会有重叠，在删除一个元素时可能会影响其他元素。
一种支持删除的方法是：将布隆过滤器中的每个比特位扩展成一个小的计数器，插入元素时给k个计数器(k个哈希函数计算出的哈希地址)加一，删除元素时，给k个计数器减一，通过多占用几倍存储空间的代价来增加删除操作。

布隆过滤器优点

  1. 增加和查询元素的时间复杂度为:O(K), (K为哈希函数的个数，一般比较小)，与数据量大小无关
  2. 哈希函数相互之间没有关系，方便硬件并行运算
  3. 布隆过滤器不需要存储元素本身，在某些对保密要求比较严格的场合有很大优势
  4. 在能够承受一定的误判时，布隆过滤器比其他数据结构有很大的空间优势
  5. 数据量很大时，布隆过滤器可以表示全集，其他数据结构不能
  6. 使用同一组散列函数的布隆过滤器可以进行交、并、差运算

布隆过滤器缺陷

  1. 有误判率，即存在假阳性(False Position)，不能准确判断元素是否在集合中(补救方法：再建立一个白名单，存储可能会误判的数据)
  2. 不能获取元素本身
  3. 一般情况下不能从布隆过滤器中删除元素
  4. 如果采用计数方式删除，可能会存在计数回绕问题

哈希切割

哈希思想除了创造出一些具有特定功能的哈希结构之外，还提供了解决一些问题的方法。
面试题：
（一）给一个超过100G大小的log file, log中存着IP地址, 设计算法找到出现次数最多的IP地址？
思路：100G的数据显然是无法直接加载到内存进行大小比较的，我们需要对这100G的文件进行拆解，假设我们将其分解成1000个小文件，现对每个文件进行编号，编号为1到1000，我们这需要一个哈希函数Hash=(hash(log)+1)%1000，保证哈希函数值为1到1000，接着读取这100G大小的文件，将数据存放到与其哈希函数值对应的文件中，那么相同的数据一定会被放到同一个文件中，此时我们只需将被这些小文件逐个加载到内存中，得到每个文件的中出现次数最多的IP地址，接着再对得到的1000个个数比较一次就可以了。由于对文件的拆分不是均等拆分，可能会有些拆解出的文件依旧过大无法放入内存，这时我们需要对这些大文件进行一下分类：

  1. 倘若该文件中没有数据的大量重复
    我们只需要换另一个哈希函数再对这些过大的文件进行拆解即可

  2. 倘若该文件中拥有大量重复数据（极端情况下全部是重复数据）
    我们只需要将数据放入map容器即可，因为map容器会对数据进行去重并记录重复数据的个数

此时如果还有大文件存在，只需重复以上步骤直至文件可以被加载到内存进行比较即可。

综上：我们只需先从大文件中读取数据插入到map中，如果map出现了异常，就换另一个哈希函数对文件进行拆解，如此递归式重复以上步骤直至文件可以被加载到内存进行比较为止。

与上题条件相同，如何找到top K的IP？
同上对文件进行哈希切割，此时只需要建一个K个元素的小堆，统计出每个文件的IP及其出现次数，以IP的出现次数为关键字插入小堆即可，程序执行完毕后小堆里存的就是出现次数为top K的IP。

（二） 给两个文件，分别有100亿个query，我们只有1G内存，如何找到两个文件交集？分别给出精确算法和近似算法
思路：
精确算法：假设两个文件为A、B，只需要使用同一个哈希函数分别对这两个文件进行哈希切割，如果某个数据是交集数据，那么其在A中被切割到的文件编号一定与其在B文件被切割到的文件编号相同，因此我们只需要在编号相同的文件中找交集，接着将所有交集合并就是A、B文件的交集，而找两个文件的交集我们只需要利用位图即可。
近似算法：如果只是近似求解，我们只需用布隆过滤器先将一个文件的数据映射到存储中，接着再将第二个文件的数据也映射到存储中，如果该数据在映射时发现对应位置都显示该数据已经存在，则可以近似认为该数据属于交集。由于此时布隆过滤器的比特位的个数只有1G内存的比特位个数，因此误判率可能较高。

黑眼圈的小熊猫
关注
  • 17
    点赞
  • 踩
  • 22
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
哈希算法及其应用场景
阅读之后，对你有帮助，那就点个赞再走吧
03-31 1230
哈希算法简单理解就是实现哈希函数的算法，用于将任意长度的二进制值串映射为固定长度的二进制值串，映射之后得到的二进制值就是哈希值（散列值）。 我们日常开发中最常见的哈希算法应用就是通过 md5 函数对数据进行加密了，md5 就是一个哈希函数，结合 md5 我们可以归纳出哈希算法的一般特性： 从哈希值不能反向推导出原始数据（所以哈希算法也叫单向算法，不可逆）； 对输入数据非常敏感，哪怕原始数据只...
哈希表及其详解
leec_55
11-14 1100
哈希前言哈希表：哈希冲突：冲突的避免1、设计哈希函数2、设置负载因子调节冲突的解决1、闭散列2、开散列/哈希桶冲突严重时的解决办法性能分析和 java 类集的关系 前言 观察下列数据 13 24 32 6 4 89 56 在刚开始接触java时，想要在一组序列中查找指定元素，可以遍历这个序列，找到与之匹配的元素，进行返回，他的时间复杂度为O(n)。 对其进行优化可以得到时间复杂度为O(log2n)的方法，即将其存储在一个二叉搜索树中，或者使用二分查找。 4 6
空间换时间（哈希思想）
qq_43016111的博客
11-16 745
【2015年计算机联考408】用单链表保存m个整数，结点的结构为：|data|link|，且|data|≤n(n 为正整 数)。现要求设计一个时间复杂度尽可能高效的算法，对于链表中 data 的绝对值相等的结点，仅保留第 一次出现的结点而删除其余绝对值相等的结点。例如，若给定的单链表 head 如下： 则删除后的 head 结点为： ...
常用的哈希函数
dayuqi的专栏
10-21 981
通用的哈希函数库有下面这些混合了加法和一位操作的字符串哈希算法。下面的这些算法在用法和功能方面各有不同，但是都可以作为学习哈希算法的实现的例子。(其他版本代码实现见下载） 1.RS  从Robert Sedgwicks的 Algorithms in C一书中得到了。原文作者已经添加了一些简单的优化的算法，以加快其散列过程。 [java] view plaincop
常用的字符串Hash函数
Archibaldyangfan的专栏
06-08 760
常用的字符串Hash函数还有ELFHash，APHash等等，都是十分简单有效的方法。这些函数使用位运算使得每一个字符都对最后的函数值产生 影响。另外还有以MD5和SHA1为代表的杂凑函数，这些函数几乎不可能找到碰撞。 常用字符串哈希函数有 BKDRHash，APHash，DJBHash，JSHash，RSHash，SDBMHash，PJWHash，ELFHash等等。对于以上几种哈 希函数
常用哈希函数介绍
热门推荐
lemon
03-31 1万+
哈希函数介绍 什么是哈希？在记录的关键字与记录的存储地址之间建立的一种对应关系叫哈希函数。 哈希函数就是一种映射，是从关键字到存储地址的映射。 通常，包含哈希函数的算法的算法复杂度都假设为O(1)，这就是为什么在哈希表中搜索数据的时间复杂度会被认为是"平均为O(1)的复杂度". 在讲解具体内容前，首先我们要清楚以下几个概念： 冲突（碰撞） 对于不同的关键字ki、kj，若ki != kj，但H(ki) = H(kj)的现象叫冲突(collision) ，即不同的输入却有相同的输出。我们应该尽量避免冲突，因为冲
哈希函数
SDAUguo的博客
05-21 579
题目： 在数据结构中，哈希函数是用来将一个字符串（或任何其他类型）转化为小于哈希表大小且大于等于零的整数。一个好的哈希函数可以尽可能少地产生冲突。一种广泛使用的哈希函数算法是使用数值33，假设任何字符串都是基于33的一个大整数，比如： hashcode("abcd") = (ascii(a) * 333 + ascii(b) * 332 + ascii(c) *33 + asc
详细解释哈希表及其应用场景
最新发布
08-25
哈希表的核心思想是利用哈希函数将键转换为数组索引。哈希函数接收键作为输入，并生成一个对应的索引值。具有相同索引值的键值对会被存储在数组的同一个位置上，这个位置就是哈希表中的桶（bucket）。当需要查找特定...
常见的哈希算法及其特点对比
其核心思想是通过散列函数对输入数据进行处理，将数据映射到一个固定长度的输出，通常称为哈希值或摘要。 ## 1.2 哈希算法的作用 哈希算法主要用于数据完整性校验、数字签名、身份验证、密码学等领域。通过比较...
基于标签嵌入的弱监督深度哈希模型及其在语义图像检索上的应用
10375基于标签嵌入的Vijetha Gattupalli，Yaoxin Zhuo，Baoxin Li亚利桑那州立大学{vijetha....在本文中，我们将语义图像哈希问题模拟为一个弱监督学习问题，利用用户生成的与图像相关的标签来学习哈希码。具体地
简单hash[或者是哈希思想]
weixin_30300523的博客
08-07 99
题目链接 /* 有一个长度为n的只包含小写字母的字符串s，有m次操作，每次输入2个字符 A , B表示将s中的全部字符A变成B，B变成A。 char sky[30],顺序记录每个字母的映射，在sky[]里做改变，然后将原 字符串通过sky[]得到答案。 //丑 */ #include<cstdio> #include<cstring> ...
哈希思想
sinat_39654987的博客
07-23 1233
基本思想：将记录的存储位置与它的关键字之间建立一个对应关系  常用的方法有：直接定址法hash(key)=key或hash(key)=a*key+b        取余法hash(key)=key%p    题意： 给一系列矩形的右上角坐标和左下角坐标，如：（5,8,7,10）表示(5,8),(7,8),(7,10),(5,10)组成的矩形，求这一系列矩形覆盖的1*1的方格的数量，重复覆盖只...
常见的哈希函数
weixin_34309435的博客
04-23 334
原理参考《算法导论》 一、除法散列函数 根据描述实现算法，先取对应种子 int hash_mod_seed(int n, int iCheck) {//存放n个关键字，一次不成功的查找要检查iCheck个关键字，默认一个字符是8位 int iStart= n / iCheck, prime = (iStart == 1) ? 2 : iStart; asse...
常用hash函数
qq_32439101的博客
08-17 613
/** * 由Justin Sobel编写的按位散列函数 */ function JSHash($string, $len = null) { $hash = 1315423911; $len || $len = strlen($string); for ($i = 0; $i < $len; $i++) { $hash ^= (($hash << 5) + ord($string[$i]) + ($hash >> 2)); .
【区块链与密码学】第5-3讲：详解常用哈希函数（一）
Digquant的博客
04-26 912
​ 【本课堂内容全部选编自PlatON首席密码学家、武汉大学国家网络安全学院教授、博士生导师何德彪教授的《区块链与密码学》授课讲义、教材及互联网，版权归属其原作者所有，如有侵权请立即与我们联系，我们将及时处理。】 5.3 SHA-256算法简介 目前常用的哈希函数有三种，分别为SHA-256算法、Keccak算法、SM3算法，今天我们对SHA-256算法进行详细讲解。 概况 SHA系列标准哈希函数是由美国标准与技术研究所(National Institute of Standards ..
哈希原理与常见哈希函数
鸣宇淳的专栏
01-09 7002
一，什么是哈希 哈希是将任意长度的数据转换为一个数字的过程。这个数字是在一个固定的范围之内的。 转换的方法称为哈希函数，原值经过哈希函数计算后得到的值称为哈希值。 1.哈希特点 (1)一致性：同一个值每次经过同一个哈希函数计算后得到的哈希值是一致的。 F(x)=rand() :每次返回一个随机值,是不好的哈希 (2)散列性：不同的值的哈希值尽量不同，理想情况下每个值对应于不同的数字。 F(x)...
哈希的思想及其应用
Slowstep_的博客
11-17 1633
哈希的思想及其应用
collection集合 地址_Java集合简介
weixin_39604685的博客
11-29 206
1、概述Java 集合框架提供了一套性能优良，使用方便的接口和类，位于java.util包中，使用集合框架的时直接从java.util中导包。Java 集合框架主要包括两种类型的容器，一种是Collection，存储一个元素集合，另一种是Map，存储键/值对映射。Collection 接口又有 3 种子类型，List、Set 和 Queue，再下面是一些抽象类，最后是具体实现类，常用的有 Arra...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值