关于哈希表的一点理解

最新推荐文章于 2024-07-24 14:48:03 发布
最新推荐文章于 2024-07-24 14:48:03 发布
阅读量1.6k 收藏 13
点赞数
分类专栏： 数据结构 数据结构C++版 文章标签： 哈希表 哈希冲突 构造哈希表的方法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_34328833/article/details/53011275
版权

哈希表>

    哈希表也叫散列表，是依据关键码值(key value)而直接进行访问的数据结构.也就是说，它通过把关键码值映射到表中的一个位置来访问记录，以加快查找的速度.这个映射函数叫做散列函数，存放记录的数组叫散列表.

    了解了什仫是哈希表之后,我们发现哈希表这种数据结构是类似于线性表的,只是表中的元素不是精密排列的，而是可能存在空间.

     比如我们存储70个元素，但是我们可能为这70个空间申请了100个元素的

空间,70/100=0.7,这个数字称为负载因子(有的书中也叫载荷因子)，x(负载因子)=填入表中的元素个数/散列表的长度,之所以存在负载因子是为了"高速存取"的目的.我们基于一种结果尽可能的随机平均分布的固定函数H为每一个元素安排存储位置，这样就能够避免遍历性质的线性搜索，以达到高速存取，但是这个结果是随机的，也必定导致冲突.

哈希冲突/哈希碰撞>

     不同的key值经过哈希函数处理后可能产生相同的值哈希地址,这种情况就叫做哈希冲突,任意的散列函数都不能避免哈希冲突.

     如何解决哈希冲突的情况呢?闭散列方法(开放定址法).,开链法/拉链法(哈希桶)

一.闭散列方法(开放定址法)>

     1).线性探测>

          

     2).二次探测>

         

     3).双散列方法>

       顾名思义双散列就是有两个散列地址,用第一个哈希函数解决不了冲突域时，用第二个继续计算，只到冲突域解决为止.双散列法优于二次探测法

二.开链法/拉链法(哈希桶)

    对关键码集合用一个散列函数计算他们存放的位置.将散列表地址相同的元素放到一个集合中，用链表链接起来.

 

   在我的代码实现中用到的解决哈希冲突的方法是闭散列中的线性探测法和拉链法,值得注意的是:降低哈希冲突最好使用素数做哈希表的容量(用素数做除数可以减少哈希冲突).

构造散列函数的方法>

    1).直接寻址法> 

     取关键字或关键字的某个线性函数值为散列地址.H(key)=key或H(key)=a*key+b,其中a,b为常数(这种散列函数叫做自身函数).若其中H(key)中已经存在数据，就往下一个找，直到H(key)中没有值了，就放进去.

    2).除留余数法> 

     取key被不大于散列表表长m的数p除后所得的余数为散列地址.Hash(key)=key%p;

    3).数字分析法

    4).平方取中法

    5).折叠法

    6).随机数法

    更详细的介绍见>http://url.cn/416R94i

   解决哈希冲突的闭散列法

      

namespace HashTable
{
	enum Status
	{
		EMPTY,
		EXIST,
		DELECT,
	};

	template<class K,class V>
	struct HashNode
	{
		K _key;
		V _value;
		Status _status;
		HashNode(const K& key=K(),const V& value=V())
			:_key(key)
			,_value(value)
			,_status(EMPTY)
		{}
	};

	template<class K>
	struct __HashFunc
	{
		size_t operator()(const K& key)
		{
			return key;
		}
	};
	//特化
	template<>
	struct __HashFunc<string>
	{
		static size_t BKDRHash(const char*str)
		{
			unsigned int seed= 131;// 31 131 1313 13131 131313
			unsigned int hash= 0;
			while(*str)
			{
				hash = hash * seed + (*str++);
			}
			return(hash& 0x7FFFFFFF);
		}
		size_t operator()(const string& str)
		{
			return BKDRHash(str.c_str());
		}
	};

	template<class K,class V,class HashFunc=__HashFunc<K>>
	class HashTables
	{
		typedef HashNode<K,V> Node;
	public:
		HashTables()
			:_size(0)
		{
			_tables.resize(_GetPrime(0));
		}
		HashTables(const HashTables<K,V,HashFunc>& hash)
		{
			size_t size=hash._tables.size();
			_tables.resize(size);
			for (size_t i=0;i<_tables.size();++i)
			{
				if (hash._tables[i]._status == EXIST)
				{
					_tables[i]._key=hash._tables[i]._key;
					_tables[i]._value=hash._tables[i]._value;
					_tables[i]._status=hash._tables[i]._status;
				}
			}
			_size=hash._size;
		}
		HashTables<K,V,HashFunc>& operator=(const HashTables<K,V,HashFunc>& hash)
		{
			if (this != &hash)
			{
				HashTables<K,V,HashFunc> tmp(hash);
				_Swap(tmp);
			}
			return *this;
		}
	public:
		bool Insert(const K& key,const V& value)
		{
			_CheckSize();
			size_t index=_GetPosition(key);
			while (_tables[index]._status == EXIST)
			{
				if (_tables[index]._key == key)
				{
					_tables[index]._value++;
					_size++;
					return false;
				}
				++index;
				if(index == _tables.size())
					index=0;
			}
			_tables[index]._key=key;
			_tables[index]._value=value;
			_tables[index]._status=EXIST;
			_size++;
			return true;
		}
		void Delete(const K& key)       //伪删除法
		{
			Node *ret=Find(key);
			if (ret != NULL)
			{
				ret->_status=DELECT;
				_size--;
			}
		}
		Node *Find(const K& key)
		{
			size_t index=_GetPosition(key);
			size_t src=index;
			while (_tables[index]._status != EMPTY)
			{
				if (_tables[index]._key == key)
				{
					if (_tables[index]._status == DELECT)
						return NULL;
					else
						return &_tables[index];
				}
				++index;
				if(index == src)
					break;
			}
			return NULL;
		}
		void Display()
		{
			for (size_t i=0;i<_tables.size();++i)
			{
				if (_tables[i]._status == EXIST)
				{
					cout<<_tables[i]._key<<" ";
				}
			}
			cout<<endl;
		}
	protected:
		void _CheckSize()
		{
			if (_tables.size() == 0 || _size*10/_tables.size() >= 8)
			{
				size_t NewSize=_GetPrime(_tables.size());
				HashTables<K,V,HashFunc> hashTable;         //现代的写法
				hashTable._tables.resize(NewSize);
				for (size_t i=0;i<_tables.size();++i)
				{
					if(_tables[i]._status == EXIST)
					{
						hashTable.Insert(_tables[i]._key,_tables[i]._value);
					}
				} 
				_Swap(hashTable);
			}
		}
		void _Swap(HashTables<K,V,HashFunc> hash)
		{
			_tables.swap(hash._tables);
			swap(_size,hash._size);
		}
		size_t _GetPrime(size_t num)
		{
			const int _PrimeSize= 28;
			//素数表
			static const unsigned long _PrimeList[_PrimeSize] =
			{
				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
			};
			for (size_t i=0;i<_PrimeSize;++i)
			{
				if(_PrimeList[i] > num)
					return _PrimeList[i];
				else
					continue;
			}
			return _PrimeList[_PrimeSize-1];
		}
		size_t _GetPosition(const K& key)        //除留余数法
		{
			HashFunc hf;
			return hf(key)%_tables.size();
		}
	protected:
		vector<Node> _tables;
		size_t _size;
	};
}


 

 

    解决哈希冲突的拉链法>

     

namespace HashTable_List
{
	template<class K,class V>
	struct HashNode
	{
		K _key;
		V _value;
		HashNode<K,V> *_next;
		HashNode(const K& key=K(),const V& value=V())
			:_key(key)
			,_value(value)
			,_next(NULL)
		{}
	};

	template<class K>
	struct __HashFunc
	{
		size_t operator()(const K& key)
		{
			return key;
		}
	};
	//偏特化
	template<>
	struct __HashFunc<string>
	{
		static size_t BKDRHash(const char*str)
		{
			unsigned int seed= 131;// 31 131 1313 13131 131313
			unsigned int hash= 0;
			while(*str)
			{
				hash = hash * seed + (*str++);
			}
			return(hash& 0x7FFFFFFF);
		}
		size_t operator()(const string& str)
		{
			return BKDRHash(str.c_str());
		}
	};

	template<class K,class V,class HashFunc=__HashFunc<K>>
	class HashTable
	{
		typedef HashNode<K,V> Node;
	public:
		HashTable()
			:_size(0)
		{}
		HashTable(const HashTable<K,V,HashFunc>& hash)
		{
			_table.resize(hash._table.size());
			for (size_t i=0;i<hash._table.size();++i)
			{
				Node *cur=_table[i];
				while (cur)
				{
					Insert(cur->_key,cur->_value);
					cur=cur->_next;
				}
			}
		}
		HashTable<K,V,HashFunc>& operator=(const HashTable<K,V,HashFunc>& hash)
		{
			if (this != &hash)
			{
				HashTable<K,V,HashFunc> tmp(hash);
				_Swap(hash);
			}
			return *this;
		}
		~HashTable()
		{
			for (size_t i=0;i<_table.size();++i)
			{
				Node *cur=_table[i];
				Node *del=NULL;
				while (cur)
				{
					del=cur;
					cur=cur->_next;
					delete del;
					del=NULL;
				}
			}
			_size=0;
			_table.clear();
		}
	public:
		Node *Find(const K& key)
		{
			int index=_GetPosition(key,_table.size());
			Node *cur=_table[index];
			while (cur)
			{
				if(cur->_key == key)
				{
					return cur;
				}
				cur=cur->_next;
			}
			return NULL;
		}
		bool Insert(const K& key,const V& value)
		{
			//头插
			_CheckSize();
			size_t index=_GetPosition(key,_table.size());
			Node *ret=Find(key);
			if(ret)       //插入的元素已经存在
			{
				ret->_value++;
				_size++;
				return false;
			}
			Node *NewNode=new Node(key,value);
			NewNode->_next=_table[index];
			_table[index]=NewNode;
			_size++;
			return true;
		}
		bool Remove(const K& key)
		{
			Node *prev=NULL;
			int index=_GetPosition(key,_table.size());
			Node *cur=_table[index];
			while (cur)
			{
				if(cur->_key == key)
				{
					if (prev == NULL)      //删除的是第一个结点
						_table[index]=cur->_next;
					else                   //删除尾结点,删除中间节点
						prev->_next=cur->_next;
					delete cur;
					cur=NULL;
					_size--;
					return true;
				}
				prev=cur;
				cur=cur->_next;
			}
			return false;
		}
		void Display()
		{
			for (size_t i=0;i<_table.size();++i)
			{
				Node *cur=_table[i];
				cout<<i<<":";
				while (cur)
				{
					cout<<cur->_key<<" ";
					cur=cur->_next;
				}
				cout<<endl;
			}
		}
	protected:
		size_t _GetPrime(size_t num)
		{
			const int _PrimeSize= 28;
			//素数表
			static const unsigned long _PrimeList[_PrimeSize] =
			{
				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
			};
			for (size_t i=0;i<_PrimeSize;++i)
			{
				if(_PrimeList[i] > num)
					return _PrimeList[i];
				else
					continue;
			}
			return _PrimeList[_PrimeSize-1];
		}
		void _CheckSize()
		{
			if (_size == 0 || _size == _table.size())
			{
				vector<Node *> tmp;
				tmp.resize(_GetPrime(_table.size()));
				for (size_t i=0;i<_table.size();++i)
				{
					Node *cur=_table[i];
					while (cur)
					{
						Node *next=cur->_next;
						size_t index=_GetPosition(cur->_key,tmp.size());
						cur->_next=tmp[index];
						tmp[index]=cur;
						cur=next;
					}
				}
				tmp.swap(_table);
			}
		}
		void _Swap(HashTable<K,V,HashFunc> hash)
		{
			_table.swap(hash._table);
			swap(_size,hash._size);
		}
		size_t _GetPosition(const K& key,size_t size)
		{
			HashFunc hf;
			return hf(key)%size;
		}
	protected:
		vector<Node *> _table;
		size_t _size;
	};
}


 


 


 

 

CTTCassie
关注
专栏目录
详解Java中用于查找对象哈希码值的hashCode()函数
09-02
当你向哈希表（如HashMap）中添加对象时，`hashCode()`被调用来计算对象的哈希码，这个哈希码随后用于确定对象在数组中的位置，因为哈希表本质上是一个基于数组的结构。哈希码的计算使得具有相同值的对象能够映射到...
一篇文章彻底搞懂哈希表
vjhghjghj的博客
03-25 1860
Table of Contents 1.原理讲解 1.1散列表的概述 1.2散列表的优缺点 1.3散列表的关键问题之散列函数的构建 1.4散列表的关键问题之散列冲突的处理 1.5散列表的性能分析 2.源码实现 2.1 节点定义 2.2 迭代器​​​​​ 2.3 数据结构 3.内存管理 3.1空间配置器 3.2 构造函数 3.3插入函数insert 3.4元素地...
哈希表原理
热门推荐
让我思考一下
07-08 1万+
哈希表是最常用的数据结构之一，对于其用法，大家都非常熟悉，这里详细探讨一下其原理。哈希表的底层实际上是基于数组来存储的，当插入键值对时，并不是直接插入该数组中，而是通过对键进行Hash运算得到Hash值，然后和数组容量取模，得到在数组中的位置后再插入。取值时，先对指定的键求Hash值，再和容量取模得到底层数组中对应的位置，如果指定的键值与存贮的键相匹配，则返回该键值对，如果不匹配，则表示哈希表中没...
【数据结构 | 哈希表】一文了解哈希表(散列表)
最新发布
wkd_007的博客
07-24 1485
👉本文介绍哈希表实现过程中的重要概念：键值对、键值、哈希函数、哈希冲突、处理哈希冲突等，看完后可以对哈希表有一定的了解。
说说哈希表/散列表
weixin_43300894的博客
06-05 2827
哈希表和散列表是一个东西，只是叫法不同而已。以下统一称呼为哈希表。 刚刚学习哈希表的时候，我其实对它的了解不是很深入，只知道它是一种key对应value的复杂数据结构。其实，哈希表包括的内容有很多。 哈希表是由哈希函数和数组组成的。 哈希函数用来产生 key值，它的主要功能是把输入映射到数字。通过哈希函数，可以把字符串或者其他类型的key值映射为数组的下标 index。 哈希函数必须满足以下特征： 1、它必须是一致的。假设哈希函数的输入是 "apple"时得到的是4，那么每次输入"a...
使用 Hashnode API、Typescript 和 GraphQL 将博客文章添加到您的 React 站点
u010291330的博客
02-16 736
多亏了 GraphQL 和 TypeScript 的魔力，我们可以在我们的应用程序和服务器/API 之间生成端到端类型安全的数据获取。这是一次性设置，将在未来加速开发，消除类型错误，并验证我们的模式。首先，该getStaticPaths函数将获取我们博客文章的所有 slug，并告诉 Next.js 我们要为我们返回的每个路径生成静态页面。所有页面都将是静态的或服务器端呈现的。现在我们有了我们的帖子列表，我们需要开始生成我们的个人页面，这是通过使用 Next.js 中非常常见的技术通过使用。
hash哈希
可乐不解渴
02-16 810
hash哈希哈希概念哈希冲突哈希函数哈希冲突解决闭散列开散列哈希表的闭散列实现哈希表闭散列结构哈希表的闭散列插入哈希表的闭散列查找哈希表的闭散列删除哈希表的开散列实现哈希表的开散列结构哈希表的开散列插入哈希表的开散列查找哈希表的开散列删除 人间四月芳菲尽，山寺桃花始盛开。 哈希概念 顺序结构以及平衡树中，元素关键码与其存储位置之间没有对应的关系，因此在查找一个元素时，必须要经过关键码的多次比较。搜索的效率取决于搜索过程中元素的比较次数，因此顺序结构中查找的时间复杂度为O (N) ，AVL树与红黑树中查找的时
哈希查找/散列查找（HashSearch）
Attract's Blog
08-22 1万+
哈希表/散列表： 1.什么是哈希表： 哈希表不同于线性表数表之处在于其查找关键字（key）时不需要遍历表，哈希表中的每一个元素都可以根据元素值计算出其存放的地址，从而达到查找时长为O（1）。 这就好比" 字典"，我们查找字典中的某个关键字（key）时，只需要查找目录即可找到该关键字（key）存放的页码（位置/地址），而查找的目录是有限的，且是线性的（常数阶/线性阶），所以无论字典存放的元素、关键字再多，我们也能通过目录快速定位查找到某个元素。 python中的 “字典(dict)” 就是如此，利用哈希表的
对块状链表的一点研究ACM NOIP
06-22
2. 查找和遍历：块状链表的查找操作可能涉及到块间的跳跃，因此需要设计高效的查找算法，如二分查找或者哈希表辅助。 3. 插入和删除：插入和删除操作需要考虑如何在保持块内连续性的同时，有效地更新指针。 苏煜的...
leetcode上班刷题-Leetcode:自己刷的力扣题，附上一点小小的理解
06-30
1. **算法基础**：LeetCode的题目覆盖了各种基础算法，如排序（快速排序、归并排序、插入排序等）、搜索（二分查找、深度优先搜索、广度优先搜索等）以及数据结构（栈、队列、链表、树、图、哈希表等）。这些是解决...
HashMapTest:测试研讨会论文的哈希映射
07-03
《HashMapTest：深入探讨哈希映射在Java中的应用》 哈希映射，作为一种高效的数据存储和检索机制，广泛应用于...哈希映射的研究和测试对于提升软件性能、优化内存使用以及理解数据结构的底层原理都具有重要意义。
java-leetcode题解之第142题环形链表II.zip
06-17
这是一道中等难度的题目，主要涉及链表操作和哈希映射技术。 环形链表是一种特殊的链表结构，其中存在一个或多个节点形成一个闭合的循环。第142题的目标是找到链表中的环的起始节点，如果链表没有环，则返回null。...
散列表（哈希表）的介绍与理解
iron__c的博客
07-08 1310
哈希表 1.定义：哈希表，英文为Hash Table，中文也可以叫做散列表，它是通过关键码值（key value）映射到表中一个位置来访问表中的元素内容，这样就可以加快查找的速度。这个映射函数叫做散列函数，存放元素内容（或者说是记录）的数组叫做散列表。 2.HashSet和HashMap的底层实现都是哈希表（散列表）！ HashSet是通过HashMap来实现的，HashSe
一文搞懂哈希表
m0_73731708的博客
04-01 282
庆哥，什么是哈希表？这个哈希好熟悉，记得好像有HashMap和HashTable之类的吧，这是一样的嘛？😊这个哈希确实经常见😂，足以说明它是个使用非常频繁的玩意儿，而且像你说的HashMap和HashTable之类的与哈希这个词肯定是有关系的，那哈希是个啥玩意啊，这个咱们还是得先来搞明白啥是个哈希表。😎，也叫），是根据（Key）而直接访问在内存存储位置的。也就是说，它通过计算一个关于键值的函数，将所需查询的数据到表中一个位置来访问记录，这加快了查找速度。这个映射函数称做，存放记录的数组称做。怎么样。
哈希表（散列表）通俗易懂解释
m0_50381275的博客
09-25 2482
在Object类中万物皆对象 Hashcode 返回值为int 提高哈希表性能 对象数组加链表 默认长度为16 （下标：0-15） 文章目录一、哈希表是什么？二、哈希表原理1.哈希函数2.特殊情况 一、哈希表是什么？ 哈希表（Hash table，也叫散列表），是根据关键码值(Key value)而直接进行访问的数据结构。也就是说，它通过把关键码值映射到表中一个位置来访问记录，以加快查找的速度。这个映射函数叫做散列函数，存放记录的数组叫做散列表。 二、哈希表原理 1.哈希函数 哈希函数 散列表是基于数组的
散列表,哈希表
欧阳北鼻的博客
07-06 661
算法
哈希表及其基础（java详解）
xiaoliii0401的博客
12-06 2372
这么详细你还拿不下哈希表？我不信。
散列表
小老弟的博客
07-02 740
通过散列函数（也叫哈希函数）将元素的键映射为数组下标（转化后的值叫做散列值或哈希值），然后在对应下标位置存储记录值。当我们按照键值查询元素时，就是用同样的散列函数，将键值转化数组下标，从对应的数组下标的位置取数据 散列冲突指的是 key1 != key2 的情况下，通过散列函数处理，hash(key1) == hash(key2)，这个时候，我们说发生了散列冲突，设计再好的散列函数也无法避免散列冲...
哈希表(散列表)介绍
weixin_57023347的博客
09-09 3226
目录 前言 一.哈希概念 1.1 什么时哈希表 1.2 哈希函数 1.3 哈希冲突 1.4 哈希冲突的解决 1.4.1 闭散列 1.4.2 开散列 1.4.3 问题 前言 哈希表时C++11两容器unordered_set和unordered_map的底层结构。它的搜索的时间复杂度为O(1)，常数次。...
理解数据结构：基础概念与重要性
- 特殊结构：如哈希表、堆栈、队列、队列、广义表等，它们提供特定的操作集和性能优势。 4. 数据结构的组成部分： - 逻辑结构：描述数据元素之间的抽象关系，如线性、树形或图状。 - 存储结构：如何在内存中实际...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值