数据结构---哈希（Hash）

最新推荐文章于 2024-05-05 22:55:34 发布
最新推荐文章于 2024-05-05 22:55:34 发布
阅读量4.2k 收藏
点赞数 1
分类专栏： 数据结构 C++语法知识
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/MEANSWER/article/details/117965978
版权

哈希


对于set和map来说底层所使用的是红黑树，其在搜索上面已经很厉害了，为什么还需要在搞一个unordered_set和unordered_map呢？ 

#include<iostream>
#include<vector>
#include<unordered_set>
#include<set>
#include<time.h>

using namespace std;

void test_time()
{
	int n = 1000000;
	vector<int> v;
	srand(time(0)); //初始化随机数发生器
	for (int i = 0; i < n; ++i)
	{
		v.push_back(rand()); //随机数发生器
	}

	set<int> s;
	size_t begin1 = clock();

	for (auto e : v)
	{
		s.insert(e);
	}
	size_t end1 = clock();

	cout << "set : " << end1 - begin1 << endl;


	unordered_set<int> us;
	size_t begin2 = clock();

	for (auto e : v)
	{
		us.insert(e);
	}
	size_t end2 = clock();

	cout << "unordered_set : " << end2 - begin2 << endl;
}

int main()
{
	test_time();
}

在这里插入图片描述
通过对于很多个数的插入（数越多，插入之间所消耗的时间差距越大），其实也是能够看出来HashTable的优越之处。

1. 哈希概念

可以不经过任何比较，一次直接从表中得到要搜索的元素。如果构造一种存储结构，通过某种函数(hashFunc)使元素的存储位置与它的关键码之间能够建立一一映射的关系，那么在查找时通过该函数可以很快找到该元素。

哈希(散列)方法，哈希方法中使用的转换函数称为哈希(散列)函数，构造出来的结构称为哈希表(Hash Table)(或者称散列表)

例如：数据集合{1，7，6，4，5，9}；
哈希函数设置为：hash(key) = key % capacity; capacity为存储元素底层空间总的大小。
在这里插入图片描述

2. 哈希函数

引起哈希冲突的一个原因可能是：哈希函数设计不够合理。

哈希函数设计原则：

  • 哈希函数的定义域必须包括需要存储的全部关键码，而如果散列表允许有m个地址时，其值域必须在0 到m-1之间。
  • 哈希函数计算出来的地址能均匀分布在整个空间中
  • 哈希函数应该比较简单

常见哈希函数

  1. 直接定制法–(常用)
    取关键字的某个线性函数为散列地址：Hash（Key）= A*Key + B优点：简单、均匀缺点：需要事先知道关键字的分布情况使用场景：适合查找比较小且连续的情况。

  2. 除留余数法–(常用)
    设散列表中允许的地址数为m，取一个不大于m，但最接近或者等于m的质数p作为除数，按照哈希函数：Hash(key) = key% p(p<=m),将关键码转换成哈希地址。

  3. 平方取中法

  4. 折叠法

  5. 随机数法

  6. 数学分析法

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

3. 哈希冲突

解决哈希冲突两种常见的方法是：闭散列和开散列

3.1 闭散列

闭散列：也叫开放定址法，当发生哈希冲突时，如果哈希表未被装满，说明在哈希表中必然还有空位置，那么可以把key存放到冲突位置中的“下一个” 空位置中去。那如何寻找下一个空位置呢？

线性探测：从发生冲突的位置开始，依次向后探测，直到寻找到下一个空位置为止。

  • 通过哈希函数获取待插入元素在哈希表中的位置
  • 如果该位置中没有元素则直接插入新元素，如果该位置中有元素发生哈希冲突，使用线性探测找到下一个空位置，插入新元素
  • 采用闭散列处理哈希冲突时，不能随便物理删除哈希表中已有的元素，若直接删除元素会影响其他元素的搜索。比如删除元素4，如果直接删除掉，44查找起来可能会受影响。因此线性探测采用标记的伪删除法来删除一个元素。
    在这里插入图片描述

载荷因子

  • 为了能够保证一直有空位置，所以这里引入了载荷因子，对于载荷因子来说，经过大量的使用最好能够控制在0.7以下最好，一旦超过就会大大增加哈希冲突的概率。

在这里插入图片描述

线性探测优点：实现非常简单，
线性探测缺点：一旦发生哈希冲突，所有的冲突连在一起，容易产生数据“堆积”，即：不同关键码占据了可利用的空位置，使得寻找某关键码的位置需要许多次比较，导致搜索效率降低。（引发踩踏效应，就像我的位置被人占了，我就去占别人的位置，后来的人都效仿，会导致效率变低）

二次探测：线性探测的缺陷是产生冲突的数据堆积在一块，这和找下一个空位置有关系，因为找空位置的方式就是挨着往后逐个去找，因此二次探测为了避免该问题，他不再是挨着找下一个空位置，而是平方式的跳跃找下一个空位置，这样冲突就不会堆积在一片，而是会相对散开一些。

比散列最大的缺陷就是空间利用率比较低，这也是哈希的缺陷。

3.1.1 闭散列模拟实现

  1. 对于闭散列来说，每个哈希表对应的位置里面存储了数据和状态
  2. 其中数据的类型是由模板的第二个参数所控制的，模板参数T是Key或者pair<const K,V>,所以这也是一种更高维度的泛型。
  3. 其中对于删除来说，采用的是一种伪删除法。因为对于闭散列来说，最需要的就是找到下一个空位置，如果没有这个状态的话，原本有数据的位置删除了就会直接的变为空位置，那么如果删除的位置刚好在你的要查找的数据之前，那么就会误认为找不到，事实上，是存在的。
  4. 对于闭散列在增容的时候所采用的方法：重新开辟一个原先二倍大小的vector，然后把你原先的数据通过新的哈希函数计算位置，然后这个新的HashTable和你原先的进行交换。
namespace Close
{

	enum State
	{
		EMPTY,
		EXIST,
		DELETE
	};

	template<class T>
	struct HashNode
	{
		State _state = EMPTY;
		T _t;
	};

	template<class K>
	struct Hash
	{
		size_t operator()(const K& key)
		{
			return key;
		}
	};

	//模板特化
	template<>
	struct Hash < string >
	{
		size_t operator()(const string& s)
		{
			size_t hash = 0;
			for (auto ch : s)
			{
				//hash += ch;
				hash = hash * 131 + ch; //
			}
			return hash;
		}
	};
	//这里和使用红黑树来封装map和set是一样的，都是由第二个模板参数来控制存储的类型是K,还是pair<const K,V>
	template<class K, class T, class HashFunc = Hash<K>>//需要把这里的K转换为整形
	class HashTable
	{
	public:
		bool Insert(const T& t)
		{
			//载荷因子= 填入表中的元素个数 / 散列表的长度
			//负载因子>0.7(严格控制在0.7以下)
			//只有在这种情况下：效率相对较高，并且空间利用率也较好
			if (_tables.size() == 0 || _size * 10 / _tables.size() == 7)
			{
				size_t newsize = _tables.size() == 0 ? 10 : _tables.size() * 2;
				//但是这里是不对的，因为有可能原来冲突的，由于空间的扩容，而不再是冲突的了，
				//所以我们应该开辟好一段空间，然后重新对上面的数据进行计算，然后放入这段空间内，在释放原来的空间


				//vector<HashNode<T>> newtables;
				//newtables.resize(newsize);

				此时就是把原空间上的数据，拿来重新计算放到相对应的新空间上
				//for (size_t i = 0; i < _tables.size(); ++i)
				//{
				//	if (_tables[i]._state == EXIST)
				//	{
				//		//线性探测找在新表中的位置
				//	}
				//}
				//newtables.swap(_tables);

				HashTable<K, T, HashFunc> newht;
				newht._tables.resize(newsize);
				for (auto& e : _tables)
				{
					if (e._state == EXIST)
					{
						//重新计算位置，然后放在这个新的表中
						newht.Insert(e._t); //拿旧空间的数据重新计算我嫌弃太麻烦，我还不如直接重新来一遍插入呢
					}
				}
				_tables.swap(newht._tables);
			}
			//不允许数据冗余
			HashNode<T>*  ret = Find(t);
			if (ret)
				return false;

			HashFunc hf;
			//这里在一开始的时候，你的哈希表里面是没有元素的，所以会出现模0，出错情况
			size_t start = hf(t) % _tables.size();
			size_t index = start; //这样写的好处就是，能够在二次探测的时候方便修改
			//线性探测,找一个空位置
			size_t i = 1;
			while (_tables[index]._state == EXIST) //应该去找下一个空位置
			{
				index = start + i;
				index %= _tables.size();
				++i;
			}
			//跳出循环就是两种情况1.EMPTY  2. DELETE这两种情况都可以把值放进去
			_tables[index]._t = t;
			_tables[index]._state = EXIST;
			_size++;

			return true;
		}

		HashNode<T>* Find(const K& key)
		{
			HashFunc hf;
			size_t start = hf(key) % _tables.size();
			size_t index = start;
			size_t i = 1;
			while (_tables[index]._state != EMPTY)
			{
				if (_tables[index]._t == key && _tables[index]._state == EXIST) //因为可能找到的这个值被删除掉了
				{
					return &_tables[index];
				}
				index = start + i;
				index %= _tables.size();
				++i;
			}
			return nullptr;
		}

		bool Erase(const K& key)
		{
			HashNode<T>* ret = Find(key);
			if (ret == nullptr)
			{
				return false;
			}
			else
			{
				//伪删除
				ret->_state = DELETE;
				return true;
			}
		}
	private:
		vector<HashNode<T>> _tables;
		size_t _size = 0; //有效数据的个数
	};
}

3.2 开散列

开散列法又叫链地址法(开链法)，首先对关键码集合用散列函数计算散列地址，具有相同地址的关键码归于同一子集合，每一个子集合称为一个桶，各个桶中的元素通过一个单链表链接起来，各链表的头结点存储在哈希表中。
在这里插入图片描述
从上图可以看出，开散列中每个桶中放的都是发生哈希冲突的元素。

那如果就是出现了极端的情况，所有的数此时都冲突到一个桶中，那么这个桶中的数据就会太多了，应该怎么办？

  1. 将此时的链表改换挂红黑树
  2. 多阶哈希（不常使用）

3.2.1 开散列模拟实现

  1. 除留余数法，最好模一个素数，如何每次快速取一个类似两倍关系的素数？这里的GetNextPrime()函数，在增容的时候，就能很好的帮助取到这个素数。
  2. 仿函数KeyOfT，是用来取出T类型（如果是unordered_set就是Key，unordered_map就是pair<const K,V>）中的Key值的。
  3. 仿函数hash是为了能够支持取模，因为一般很多时候K都是字符串类型，但是string是不支持取模的，所以需要将其转化为整数，在取模。但是单纯的使用ASCII码值相加，字符串还是容易发生冲突，所以这里又引入了一个字符串哈希算法，最常使用的就是C语言之父所写的BKDRHash算法，也就是给每个字符先乘131，然后在把字符的ASCII码进行相加。当然这里还是用到了模板的特化，当数据是具体的string的时候，就会调用这个仿函数进行计算。
  4. 对于迭代器operator++的实现需要使用到HashTable，因为当一个哈希桶内数据遍历完了以后，需要跳到下一个桶，但是如果没有这个HashTable的话，就无法找到下一个桶位置。
  5. 在使用迭代器的时候需要HashTable但是此时还没有实例化出来，所以需要一个前置声明。
  6. 需要在HashTable中将HashIterator声明为友元。（因为迭代器需要使用HashTable的私有成员）
namespace Open
{
	size_t GetNextPrime(size_t prime)
	{
		static const int PRIMECOUNT = 28;
		static const size_t primeList[PRIMECOUNT] =
		{
			53ul, 97ul, 193ul, 389ul, 769ul,
			1543ul, 3079ul, 6151ul, 12289ul, 24593ul,
			49157ul, 98317ul, 196613ul, 393241ul, 786433ul,
			1572869ul, 3145739ul, 6291469ul, 12582917ul, 25165843ul,
			50331653ul, 100663319ul, 201326611ul, 402653189ul, 805306457ul,
			1610612741ul, 3221225473ul, 4294967291ul
		};

		size_t i = 0;
		for (; i < PRIMECOUNT; ++i)
		{
			if (primeList[i] > prime)
				return primeList[i];
		}

		return primeList[i];
	}

	template<class T>
	struct HashLinkNode
	{
		T _t;
		HashLinkNode<T>* _next;

		HashLinkNode(const T& t)
			: _t(t)
			, _next(nullptr)
		{}
	};

	template<class K>
	struct Hash
	{
		size_t operator()(const K& key)
		{
			return key;
		}
	};

	// 特化
	template<>
	struct Hash < string >
	{
		size_t operator()(const string& s)
		{
			size_t hash = 0;
			for (auto ch : s)
			{
				//hash += ch;
				hash = hash * 131 + ch;
			}

			return hash;
		}
	};

	//前置声明，因为在构造迭代器的时候，需要HashTable，但是这里模板还没有进行特化，找不到
	template<class K, class T, class KeyOfT, class hash>
	class HashTable;

	//对于封装迭代器来说，++那么就会跳到桶里面的下一个结点的位置，但是当这个桶不再有结点的时候，就需要直接的跳到下一个有hash映射的位置
	template<class K, class T, class Ref,class Ptr ,class KeyOfT, class hash> 
	struct HashIterator
	{
		typedef HashIterator<K, T, Ref,Ptr,KeyOfT, hash> Self;
		typedef HashLinkNode<T> Node;
		Node* _node;
		HashTable<K, T, KeyOfT, hash>* _pht; //还需要一个指向哈希表的指针，因为需要遍历哈希表，如果此时这个通遍历完了
		//能够帮助找到下一个需要到跳跃的位置

		HashIterator(Node* node, HashTable<K, T, KeyOfT, hash>* pht)
			:_node(node)
			, _pht(pht)
		{}

		Ref operator*()
		{
			return _node->_t;
		}

		Ptr operator->()
		{
			return &(_node->_t);
		}

		bool operator!=(const Self& s) const 
		{
			return _node != s._node;
		}
		//哈希表的迭代器是没有--的，因为这是一个单项迭代器
		//对于operator++（前置++）来说，加完之后依旧返回的是一个迭代器的指针
		//1. 当前桶还有数据，继续走
		//2. 当前桶没有数据，跳到下一个桶，从第一个开始
		Self operator++()
		{
			if (_node->_next)
			{
				_node = _node->_next;
			}
			else
			{
				KeyOfT kot;
				//一个桶已经走完了，找到下一个桶
				//因为我在当前桶是可以算出我的位置的，但是还需要一个hash表
				//走到这里说明我算出来的index的原来位置，已经全部都走完了，那么应该从他的下一个位置开始计算
				size_t index = _pht->HashFunc(kot(_node->_t),_pht->_tables.size());
				++index;
				while (index < _pht->_tables.size())
				{
					if (_pht->_tables[index])
					{
						//就开始遍历这个桶
						_node = _pht->_tables[index];
						break;
					}
					else
					{
						++index;
					}
				}

				//但是while结束有可能是两种可能1.break跳出来的   2.循环走结束了
				//所以这两种情况最好能够区分一下
				if (index == _pht->_tables.size())
				{
					_node = nullptr;
				}
			}
			return *this;
		}
	};


	template<class K,class T,class KeyOfT,class hash = Hash<K>>
	class HashTable
	{
		typedef HashLinkNode<T> Node;
		friend struct HashIterator < K, T, T&, T*, KeyOfT, hash > ;
	public:
		typedef HashIterator<K, T, T&,T*,KeyOfT, hash> Iterator;
		typedef HashIterator<K, T, const T&, const T*, KeyOfT, hash> Const_Iterator;
		Iterator Begin()
		{
			for (size_t i = 0; i < _tables.size(); ++i)
			{
				if (_tables[i])
				{
					return Iterator(_tables[i],this); //this是指向HashTable的指针
				}
			}

			//如果哈希表中一个数据也没有，那么返回nullptr也是正确的
			return End();
		}
		Iterator End()
		{
			return Iterator(nullptr,this);
		}

		size_t HashFunc(const K& key, size_t n)
		{
			hash hf;
			size_t ki = hf(key);
			return ki % n;
		}
	
		pair<Iterator, bool> Insert(const T& t)
		{
			//对于开散列/哈希桶依旧要考虑负载因子的问题,但是一般控制在1，也就是满了在加，空间利用率更高
			//自己冲突的多，只会影响我自己，不会影响别人
			KeyOfT kot;
			//控制负载因子 == 1的时候增容
			if (_size == _tables.size())
			{
				size_t newsize = GetNextPrime(_tables.size());//得到素数,有效验证能够提高效率
				vector<Node*> newtables;
				newtables.resize(newsize,nullptr);

				//循环的把每个哈希桶拿过来，重新挂接
				for (size_t i = 0; i < _tables.size(); ++i)
				{
					//旧表中结点直接取下来挂在新表中
					Node* cur = _tables[i];
					while (cur)
					{
						Node* next = cur->_next;
						size_t index = HashFunc(kot(cur->_t),newtables.size());//重新计算在所开辟的新表中的位置
						//头插
						cur->_next = newtables[index];
						newtables[index] = cur;

						cur = next;
					}
					_tables[i] = nullptr;//因为你算来的表   指针可能还指向着这个位置
				}
				newtables.swap(_tables);
			}

			//需要得到下标的位置
			size_t index = HashFunc(kot(t),_tables.size());//首先把T里面的key提取出来，但是还是不能够确定是否可以取模，所以还需要在套用一层
			
			//不允许键值冗余，所以需要查找t在不在
			//先找到那个位置，然后在遍历整个哈希桶
			Node* cur = _tables[index];
			while (cur)
			{
				if (kot(cur->_t) == kot(t))
				{
					return make_pair(Iterator(cur,this), false);
				}
				cur = cur->_next;
			}

			//对于哈希表中一开始存储的是NULL，当底下有挂接的时候，存储的将会变为第一个结点的地址
			//头插到链表桶里面
			Node* newnode = new Node(t);
			newnode->_next = _tables[index];
			_tables[index] = newnode;

			return make_pair(Iterator(newnode,this), true);
		}

		//Find就是通过Key来寻找的
		Iterator Find(const K& key)
		{
			KeyOfT kot;
			size_t index = HashFunc(key,_tables.size());
			Node* cur = _tables[index];
			//现在hash表中找到位置，然后在遍历该位置的整个hash桶
			while (cur)
			{
				if (kot(cur->_t) == key)
				{
					return Iterator(cur,this);
				}
				cur = cur->_next;
			}
			return End();
		}
		bool Earse(const K& key)
		{
			KeyOfT kot;
			size_t index = HashFunc(key, _tables.size());
			//这里就是一个单链表的删除
			Node* prev = nullptr;
			Node* cur = _tables[index];
			//现在hash表中找到位置，然后在遍历该位置的整个hash桶
			while (cur)
			{
				if (kot(cur->_t) == key)
				{
					//就进行删除
					if (prev == nullptr)
					{
						//说明删除的是头
						_tables[index] = cur->_next; //链表挂接的第一个就直接找到了
					}
					else
					{
						prev->_next = cur->_next;
					}
					delete cur;
					return true;
				}
				else
				{
					prev = cur;
					cur = cur->_next;
				}
			}
			return false;
		}
	private:
		vector<Node*> _tables;
		size_t _size = 0;//有效数据的个数
	};

}

4. 基于开散列实现unordered_set

  1. 对于unordered_set来说实现迭代器，其实就是对HashTable进行了一层封装，但是HashTable的迭代器也是由模板所实现的，所以这里的typename还有另外的作用：先别急着报错，先等一等，等具体实例化了再来找，如果还没有在报错也不出。
#pragma once
#include "HashTable.hpp"

//其实和map和set一样，本身他们自身是没有什么东西的，他们的种种操作都是在红黑树的基础上所实现的
//现在的unordered_set和unordered_map也是，都是在开散列HashTable基础上所实现的
namespace wzy
{
	template<class K,class hash = Open::Hash<K>> //对于orderedset_set来说你想怎样使用，你就怎么控制这个模板参数
	class unordered_set
	{
		struct SetKOfT
		{
			const K& operator()(const K& k)
			{
				return k;
			}
		};
	public:
		typedef typename Open::HashTable<K, K, SetKOfT, hash>::Iterator iterator;

		iterator begin()
		{
			return _t.Begin();
		}

		iterator end()
		{
			return _t.End();
		}

		iterator find(const K& key)
		{
			return _t.Find(key);
		}

		bool earse(const K& key)
		{
			return _t.Earse(key);
		}
		pair<iterator, bool> insert(const K& k)
		{
			return _t.Insert(k);
		}

	private:
		Open::HashTable<K, K, SetKOfT, hash> _t;
	};

	void test_unordered_set()
	{
		wzy::unordered_set<int> us;
		us.insert(1);
		us.insert(54);
		us.insert(58);
		us.insert(59);
		us.insert(21);
		us.insert(22); 
		us.insert(23);
		us.insert(24);
		for (auto& e : us)
		{
			cout << e << " ";
		}
		cout << endl;

		unordered_set<int>::iterator it = us.find(22);
		cout << *it << endl;

		us.earse(24);
		us.earse(21);
		us.earse(22);
		for (auto& e : us)
		{
			cout << e << " ";
		}
		cout << endl;
	}
}

在这里插入图片描述

5. 基于开散列实现unordered_map

  1. 对于unordered_map来说，重载了[],对于这个返回的是Value的引用。
#pragma once 
#include"HashTable.hpp"

namespace wzy
{
	template<class K,class V,class hash = Open::Hash<K>>
	class unordered_map
	{
		struct MapKOfT
		{
			const K& operator()(const pair<const K, V>& kv)
			{
				return kv.first;
			}
		};

	public:
		typedef typename Open::HashTable<K, pair<const K, V>, MapKOfT, hash>::Iterator iterator;
		pair<iterator, bool> insert(const pair<const K, V>& kv)
		{
			return _ht.Insert(kv);
		}

		iterator begin()
		{
			return _ht.Begin();
		}

		iterator end()
		{
			return _ht.End();
		}

		iterator find(const K& key)
		{
			return _ht.Find(key);
		}

		bool earse(const K& key)
		{
			return _ht.Earse(key);
		}

		V& operator[](const K& key)
		{
			pair<iterator,bool> ret = insert(make_pair(key, V()));
			return ret.first->second;
		}
	private:
		Open::HashTable<K, pair<const K, V>, MapKOfT,hash> _ht;
	};

	void test_unordered_map()
	{
		wzy::unordered_map<int, int> um;
		um.insert(make_pair(1, 1));
		um.insert(make_pair(2, 1));
		um.insert(make_pair(3, 1));

		unordered_map<int,int>::iterator it = um.begin();
		while (it != um.end())
		{
			cout << it->first << ":"<<it->second<<endl;
			++it;
		}

		wzy::unordered_map<string,string> dict;
		dict["hash"] = "哈希";
		dict["sort"] = "排序";
		dict["insert"] = "插入";
		dict["find"] = "查找";

		for (auto& e : dict)
		{
			cout << e.first << ":" << e.second << endl;
		}

		cout <<endl;

		dict.earse("hash");
		dict.earse("find");
		for (auto& e : dict)
		{
			cout << e.first << ":" << e.second << endl;
		}
	}
}

在这里插入图片描述

6. 闭散列和开散列对比

由于开放定址法必须保持大量的空闲空间以确保搜索效率，并且非常容易发生踩踏效应，如二次探查法要求装载因子a <= 0.7，而表项所占空间又比指针大的多，所以使用链地址法反而比开地址法节省存储空间。相对于开放定址法来说，开链法的空间利用率为1，只有满的时候才需要增容(空间利用率很高)，并且不同的位置冲突值不再相互干扰踩踏。

没什么..
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
详解哈希数据结构，手写哈希表
CRMEB小程序商城的博客
10-18 6027
哈希表，终于姗姗来迟了。 本文系统讲解了哈希表数据结构的相关概念，并以HashMap为案例讲解一下它与普通哈希表的不同点，最后也手写一个简易的哈希表。 所以通过本文，我希望读者们能对哈希表有一个清楚的认识，尤其是在Java面试过程中，HashMap的相关面试题几乎是逢面必问，如果你连哈希表结构都不清楚，那真的很难从根上理解HashMap。 除了面试，在你掌握了哈希表之后也可以根据应用场景的需要，对哈希函数进行重写，以此来保证在你的应用场景下哈希分布的更加均匀。 本文概览如下： 哈希表 散列表（Hash
数据结构之hash
FintechBoy的博客
08-28 210
hash函数、布隆过滤器、分布式一致性hash
[数据结构] 哈希（Hash）
最新发布
NilEra的博客
05-05 698
此时插入和查找的代码也要发生相应的改变，插入时需要我们需要找到一个空位置来执行插入操作；：插入时可能会出现多次冲突，当哈希表即将满的时候，插入操作的冲突可能会出现的更多，此时插入和查询操作都会变成一个非常耗时的操作。我们可以通过链表的方式，来实现在一个位置放置多个元素的操作。一种很好想到的解决方式是将哈希表中插入时产生冲突的元素向后顺延，直到找到一个空位置再进行插入。面对上面的问题，设计好哈希函数才是解决问题的关键。通过这种方式，每次查找元素时，先找到对应的链表头，然后遍历这个位置的整张链表即可。
哈希-基础数据结构
hi332516_1的博客
03-13 881
目录 第一部分：哈希基本概念 第二部分：哈希冲突 第三部分：哈希函数的六种构造方法 第四部分：如何处理哈希冲突 第五部分：链地址法代码实现 第一部分：哈希基本概念 哈希：1.哈希基础 如果构造哈希 如果发生哈希冲突，怎么解决？ 2.一致哈希 虚拟节点 3.布隆过滤器 海量数据如何去重 目的：可以在第一时间内确定这个x值到底在不在这个数组？ 数据和存储位置没有任何关系 例：我想在一组数中寻找数33 只能从前向后全部遍历一遍这个数组，确定33是不是在这个数组中，时间复杂度..
数据结构——哈希表
u014374826的博客
07-05 4162
hash table
数据结构 - 哈希表（散列表）
gghhb12的博客
04-23 3143
数据结构 - 哈希表（散列表）
哈希表-使用C语言实现哈希表数据结构-HashTable.zip
03-04
哈希表是一种高效的数据结构，它通过特定的函数——哈希函数，将任意大小的键（key）映射到一个固定大小的数组索引上，从而实现快速的查找、插入和删除操作。在C语言中实现哈希表，我们需要理解以下几个关键概念和...
Tabela-Hash:数据结构-哈希表
03-31
哈希表，也被称为散列表，是数据结构中一种高效的数据存储和检索工具。它通过将键（key）映射到一个确定的位置来实现快速访问，这个位置通常称为哈希码或哈希值。在C语言中实现哈希表，需要理解其基本原理和常见算法...
cpp代码-数据结构-hash
07-14
在IT领域，尤其是在编程中，数据结构和算法是核心部分，而哈希（Hash）作为数据结构的一种，具有高效查找和存储的特点，广泛应用于各种软件系统。本篇将围绕"cpp代码-数据结构-hash"这一主题，深入探讨哈希表在C++中...
数据结构中常见的哈希表，到底是什么？
Edison's 小宇宙
04-09 8万+
散列表（Hash table），根据关键码值而直接进行访问的数据结构。它通过把关键码值映射到表中一个位置来访问记录，以加快查找的速度。
HashMap里的Node
止境博客
11-13 7648
一。 HashMap类中的Node<K,V>类里有一个Node<K,V> next。那以Node<K,V>.next.next.next这种结构形式存储元素就是所说的链表，而Node<K,V>[ ] tab就是数组，tab所存储元素为每个链表的第一个元素。 每个数组的位置就是一个哈希值，如果两个值哈希值一样，就会占用一个位置，他们就成了一个链表 ...
常用哈希函数结构 数据结构
05-07
目前比较有名的哈希函数 C语言 数据结构
高阶数据结构—— 哈希
lyzzs222的博客
11-06 527
哈希数据结构，具体模拟实现哈希表和哈希桶，对哈希冲突的处理方法，哈希的概念，哈希映射？数据可哈希的转换？ 这里都有。
浅谈算法和数据结构: 十一 哈希表
weixin_34234823的博客
10-31 1493
在前面的系列文章中，依次介绍了基于无序列表的顺序查找，基于有序数组的二分查找，平衡查找树，以及红黑树，下图是他们在平均以及最差情况下的时间复杂度： 可以看到在时间复杂度上，红黑树在平均情况下插入，查找以及删除上都达到了lgN的时间复杂度。 那么有没有查找效率更高的数据结构呢，答案就是本文接下来要介绍了散列表，也叫哈希表(Hash Table) 什么是哈希表 哈希表就是一种以 键-值(k...
数据结构与算法分析：哈希表
liyuefeilong的专栏
09-25 8761
哈希表又叫散列表，是实现字典操作的一种有效数据结构。哈希表的查询效率极高，在没有冲突（后面会介绍）的情况下可做到一次存取便能得到所查记录，在理想情况下，查找一个元素的平均时间为O(1)（最差情况下散列表中查找一个元素的时间与链表中查找的时间相同：O(n)，但实际情况中一般散列表的性能是比较好的）。
nodejs对字符串hash
戎码江湖
10-21 4370
将字符串进行hash const sha256 = require(“sha256”); sha256(需要传入的字符串); 参考网址：https://www.npmjs.com/package/sha256
哈希表（散列表）原理详解
热门推荐
那年聪聪
06-03 28万+
哈希表（散列表）原理详解
【数据结构--散列函数】
Lyao_Boker的博客
01-23 8409
散列函数的设计散列查找的基本思想散列函数的设计原则三种常见的散列函数1. 直接定址法2. 除留余数法3. 平方取中法处理冲突的方法1. 开放定址法2. 拉链法(链地址法) 散列查找的基本思想 在记录的存储位置和它的关键码之间建立一个确定的对应关系H，使得每个关键码key和唯一的存储位置H(key)相对应。 存储记录时，根据这个对应关系找到关键码的映射地址，并按此地址存储该记录；查找记录时，根据这个对应关系找到待查找关键码的映射地址，并按此地址访问该记录。 采用散列技术将记录存储在一块连续的存储空间中，这块连
数据结构——HashMap
Jae_Peng的博客
03-15 1万+
众所周知，HashMap 是一个用于存储Key-Value键值对的集合，每一个键值对也叫做 Entry。 这些个键值对（Entry）分散存储在一个数组当中，这个数组就是HashMap的主干。 HashMap 数组每一个元素的初始值都是 Null。 对于HashMap，我们最常使用的是两个方法：Get 和 Put。 1. Put 方法的原理 调用 Put 方法的时候发生了什么呢？ ...
数据结构课程设计----哈希表设计
12-24
哈希表是一种常用的数据结构，它可以高效地存储和检索数据。在哈希表中，数据元素通过哈希函数转换为索引，然后存储在数组中。哈希函数将数据元素映射到数组的特定位置，这样可以快速地访问和操作数据。 下面是一个...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值