【数据结构】哈希表/散列表

本篇博文,旨在介绍哈希表的基本概念及其用法;介绍了减少哈希冲突的方法;并用代码实现了哈希表的线性探测和哈希桶


哈希表的基本概念

哈希表是一种存储结构,它通过key值可以直接访问该key值在内存中从存储位置;

将关键值映射到表中的位置访问数据,这个映射函数叫做散列函数,存储数据的表叫做散列表;

构造哈希表的几种方法

1、直接定址法

根据关键值直接确定元素存取的位置,该散列函数是一个线性函数;例如 Hash(key) = A*key+B,其中,A和B都为常数

2、除留余数法

取出关键值后,将关键值除以该散列表的长度从而获得的余数,作为散列地址;Hash(key) = key%m

3、平方取中法

取关键字平方后的中间几位为哈希地址。由于一个数的平方的中间几位与这个数的每一位都有关,因而,平方取中法产生冲突的机会相对较小。

平方取中法中所取的位数由表长决定。

例: K = 456,K2 = 207936 若哈希表的长度m=102,则可取79(中间两位)作为哈希函数值。

4、折叠法

将关键字分割成位数相同的几部分,最后一部分位数可以不同,然后取这几部分的叠加和(去除进位)作为散列地址。数位叠加可以有移位叠加和间界叠加两种方法。

5、随机数法

选择一随机函数,取关键字的随机值作为散列地址,通常用于关键字长度不同的场合。

6、数学分析法

找出数字的规律,尽可能利用这些数据来构造冲突几率较低的散列地址。

哈希冲突/哈希碰撞

哈希冲突出现的原因

关键值通过任何的散列函数获得的散列地址都有可能是重复的,这种情况叫做哈希冲突;

载荷因子

散列表的载荷因子的定义为:a = 表中的元素个数/散列表的长度

对于开放定址法,载荷因子特别重要,一般情况下严格控制在0.7-0.8

超过0.8,哈希表的效率会很低

过低的话,浪费的空间会更大


任何的散列函数都是无法避免的,在处理哈希冲突的方法中,我们介绍下面两种方法

a 用开放定址法来处理哈希冲突

a1 线性探测

当有需要插入元素的位置已经有元素存在时,则向后遍历寻找空位置


a2 二次探测

当插入位置冲突时,则向后寻找,但不是每次只挪动一个位置,而是冲突次数的平方次(1,4,9....)


b 用开链法处理哈希冲突

哈希桶是一种顺序表和链表的结合体,定义一个数组,数组存储的内容是节点的指针,下面用一个个桶来存储元素;

这样可以提高哈希表的效率


如何减少哈希冲突

a 素数

使用素数做除数可以有效的减少哈希冲突

//素数表
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
};

b 字符串哈希算法

字符串哈希算法就是将一个字符串转化成一个Key值

字符串哈希算法有很多

下面这个链接有详细的介绍

http://www.cnblogs.com/-clq/archive/2012/05/31/2528153.html

代码实现

开放定址法的线性检测

节点的定义:

//定义枚举,表示节点的状态
enum Status
{
	EXIST,DELETE,EMPTY,};

//节点的定义
template<typename K,typename V>
struct HashNode
{
	K _key;
	V _value;
	Status _status;

	HashNode(const K& key = K(),const V& value = V())
		:_key(key),_value(value),_status(EMPTY)
	{}
};

状态位标识着这个位置有没有值存在,还是之前存在已被删除

哈希表的定义:

//HashFunc是采用的字符串哈希算法
template<typename K,typename V,typename HashFunc = __HashFunc<K>>
class HashTable
{
	typedef HashNode<K,V> Node;
public:
	//缺省的构造函数
	HashTable()
	{}

	//构造函数
	HashTable(size_t size);

	//将K值转换成哈希值
	size_t HashFunC(const K& key);

	//插入一组值
	pair<Node*,bool> Insert(const K& key,const V& value);

	//查找元素
	Node* find(const K& key);

	//删除一个节点
	void Remove(const K& key);

protected:
	vector<Node> _v;//用vector的下标标志位置
	size_t _size;//哈希表中元素的数量
protected:
	//交换两个哈希表
	void Swap(HashTable<K,V> &h);
	
	//进行容量的判别,进行扩容
	void CheckCapacity();
};

插入函数的实现:

	pair<Node*,const V& value)
	{
		//检查是否需要扩容
		CheckCapacity();

		//对K值进行取余,判断插入的位置
		size_t index = HashFunC(key);

		//如果存在,则循环着继续寻找
		while (_v[index]._status == EXIST)
		{
			index++;
			if (index == _v.size())
				index = 0;
		}

		_v[index]._key = key;
		_v[index]._value = value;
		_v[index]._status = EXIST;

		_size++;

		return make_pair<Node*,bool>(&_v[index],true);
	}

插入函数,要找到关键值对应的位置,冲突的话后移;找到后放入对应的Key和value值,并且将状态位改变即可

查找函数的实现:

        Node* find(const K& key)
	{
		//对K值进行取余,判断插入的位置
		size_t index = HashFunC(key);

		//如果存在,则继续寻找
		while (_v[index]._status == EXIST)
		{
			//若相等,判断状态是否是删除
			//若删除,则没找到,返回空
			//若没删除,则返回该位置的地址
			if (_v[index]._key == key)
			{
				if (_v[index]._status == DELETE)
					return NULL;

				return &_v[index];
			}

			index++;
			if (index == _size)
				index = 0;
		}

		return &_v[index];
	}

线性探测中,查找这块有个小问题。当一个关键值是因为冲突后移的话,若后移中的某个值之后删除了,就无法找到这个值了

删除函数的实现:

        void Remove(const K& key)
	{
		//删除仅需要将状态修改
		Node* delNode = find(key);

		if (delNode)
			delNode->_status = DELETE;
	}

先查找是否存在,存在的话只需要将状态位修改成删除即可

扩容函数的实现:

载荷因子超过0.7时,进行扩容

	void CheckCapacity()
	{
		//如果_v为空,则扩容到7
		if (_v.empty())
		{
			_v.resize(_PrimeList[0]);
			return;
		}

		//如果超过载荷因子,则需要扩容
		if (_size*10 / _v.size() >= 7)
		{
			/*size_t newSize = 2 * _v.size();*/

			size_t index = 0;
			while (_PrimeList[index] < _v.size())
			{
				index++;
			}
			size_t newSize = _PrimeList[index];

			//用一个临时变量来存储新生成的哈希表
			//生成完成后,将其和_v交换
			HashTable<K,V> tmp(newSize);
			for (size_t i = 0; i < _v.size(); ++i)
			{
				//如果存在,则将该位置的哈希值插入到临时的哈希表中
				if (_v[i]._status == EXIST)
					tmp.Insert(_v[i]._key,_v[i]._value);
			}
			//交换两个哈希表
			Swap(tmp);
		}
	}

开链法 哈希桶

节点的定义:

//节点的定义
template<class K,class V> 
//struct HushNode  e2:拼写错误,Hash not hush
struct HashNode  
{
	K _key;
	V _value;
	HashNode<K,V>* _next;
	HashNode(const K& key,const V& value)
		:_key(key),_next(NULL)
	{}
};

插入函数的实现:

//插入函数的实现
	pair<Node*,const V& value)
	{
		//插入之前要先进行是否扩容的检查
		CheckCapacity();
		//找到这个数的位置
		size_t index = _HushFunc(key);
		Node* cur = _ht[index];
		while (cur)
		{
			if (cur->_key == key)
				return make_pair(cur,false);
			cur = cur->_next;
		}
		Node* temp = new Node(key,value);
		temp->_next = _ht[index];
		_ht[index] = temp;
		return make_pair(temp,true);
	}

用pair可以返回插入成功后节点的指针(或插入失败,相同关键值的指针),以及判断插入成功与否的TRUE或FALSE

删除函数的实现:

	//删除函数的实现
	void Erase(const K& key)
	{
		//先进行查找这个数的位置
		size_t index = _HushFunc(key);
		Node* pre = NULL;
		Node* cur = _ht[index];
		//删除的时候要进行情况的分析讨论
		while (cur)
		{
			if (pre == NULL)
			{
				_ht[index] = cur->_nex;
				delete cur;
			}
			else
			{
				pre->_next = cur->_next;
			}
			cur = cur->_next;

		}
                delete cur;
	}

删除元素的时候,需要分两种情况

a、链上有且仅有该节点

出现这种情况,就是pre为空时,仅需修改vector对应位置存储的指针

b、链上除该节点外,还有多个节点

将cur的指向下一个节点的指针给pre的下一个

查找函数的实现:

	//查找函数的实现
	Node* Find(const K& key)
	{
		for (int i = 0; i<_size; i++)
		{
			Node* cur = _ht[i];
			while (cur)
			{
				if (cur->_key == key)
					return cur;
				cur = cur->_next;
			}
		}
		return NULL;
	}

扩容函数的实现:

	void CheckCapacity()
	{
		//当哈希桶为空的时候或者负载因子为1的时候,进行扩容
		if (_ht.size() == 0 || _size / _ht.size() == 1)
		{
			//建一个新表
			HushTable temp;
			size_t newsize = GetNewSize();
			temp._ht.resize(newsize);

			//将元素放进去
			for (int i = 0; i<_ht.size(); i++)
			{
				Node* cur = _ht[i];
				while (cur)
				{
					temp.Insert(cur->_key,cur->_value);
					cur = cur->_next;
				}
			}
		}
	}

与线性探测不同的是,这里当载荷因子为1的时候进行扩容;

哈希桶的一种极端情况是,所有值都往同一个位置进行插入

如下:


解决方法:

当一个链上的节点数量达到一个百分比(自己定义,可以是100%,50%,10%),则不再存储链表,而是存储一颗红黑树

这一避免出现这种极端情况而带了的弊端


哈希表的github代码链接

https://github.com/haohaosong/DataStruct/blob/master/HashTable.h

哈希桶的github代码链接

https://github.com/haohaosong/DataStruct/blob/master/HashTableBucket.h

版权声明:本文内容由互联网用户自发贡献,该文观点与技术仅代表作者本人。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容, 请发送邮件至 dio@foxmail.com 举报,一经查实,本站将立刻删除。

相关推荐


【啊哈!算法】算法3:最常用的排序——快速排序       上一节的冒泡排序可以说是我们学习第一个真正的排序算法,并且解决了桶排序浪费空间的问题,但在算法的执行效率上却牺牲了很多,它的时间复杂度达到了O(N2)。假如我们的计算机每秒钟可以运行10亿次,那么对1亿个数进行排序,桶排序则只需要0.1秒,而冒泡排序则需要1千万秒,达到115天之久,是不是很吓人。那有没有既不浪费空间又可以快一点的排序算法
匿名组 这里可能用到几个不同的分组构造。通过括号内围绕的正则表达式就可以组成第一个构造。正如稍后要介绍的一样,既然也可以命名组,大家就有考虑把这个构造作为匿名组。作为一个实例,请看看下列字符串: “08/14/57 46 02/25/59 45 06/05/85 18 03/12/88 16 09/09/90 13“ 这个字符串就是由生日和年龄组成的。如果需要匹配年两而不要生日,就可以把正则
选择排序:从数组的起始位置处开始,把第一个元素与数组中其他元素进行比较。然后,将最小的元素方式在第0个位置上,接着再从第1个位置开始再次进行排序操作。这种操作一直到除最后一个元素外的每一个元素都作为新循环的起始点操作过后才终止。 public void SelectionSort() { int min, temp;
public struct Pqitem { public int priority; public string name; } class CQueue { private ArrayList pqueue; public CQueue() { pqueue
在编写正则表达式的时候,经常会向要向正则表达式添加数量型数据,诸如”精确匹配两次”或者”匹配一次或多次”。利用数量词就可以把这些数据添加到正则表达式里面了。 数量词(+):这个数量词说明正则表达式应该匹配一个或多个紧紧接其前的字符。 string[] words = new string[] { "bad", "boy", "baad", "baaad" ,"bear", "b
来自:http://blog.csdn.net/morewindows/article/details/6678165/归并排序是建立在归并操作上的一种有效的排序算法。该算法是采用分治法(Divide and Conquer)的一个非常典型的应用。首先考虑下如何将将二个有序数列合并。这个非常简单,只要从比较二个数列的第一个数,谁小就先取谁,取了后就在对应数列中删除这个数。然后再进行比较,如果有数列
插入排序算法有两层循环。外层循环会啄个遍历数组元素,而内存循环则会把外层循环所选择的元素与该元素在数组内的下一个元素进行比较。如果外层循环选择的元素小于内存循环选择的元素,那么瘦元素都想右移动以便为内存循环元素留出位置。 public void InsertionSort() { int inner, temp;
public int binSearch(int value) { int upperBround, lowerBound, mid; upperBround = arr.Length - 1; lowerBound = 0; while (lowerBound <= upper
虽然从表内第一个节点到最后一个节点的遍历操作是非常简单的,但是反向遍历链表却不是一件容易的事情。如果为Node类添加一个字段来存储指向前一个节点的连接,那么久会使得这个反向操作过程变得容易许多。当向链表插入节点的时候,为了吧数据复制给新的字段会需要执行更多的操作,但是当腰吧节点从表移除的时候就能看到他的改进效果了。 首先需要修改Node类来为累增加一个额外的链接。为了区别两个连接,这个把指
八、树(Tree)树,顾名思义,长得像一棵树,不过通常我们画成一棵倒过来的树,根在上,叶在下。不说那么多了,图一看就懂:当然了,引入了树之后,就不得不引入树的一些概念,这些概念我照样尽量用图,谁会记那么多文字?树这种结构还可以表示成下面这种方式,可见树用来描述包含关系是很不错的,但这种包含关系不得出现交叉重叠区域,否则就不能用树描述了,看图:面试的时候我们经常被考到的是一种叫“二叉树”的结构,二叉
Queue的实现: 就像Stack类的实现所做的一样,Queue类的实现用ArrayList简直是毋庸置疑的。对于这些数据结构类型而言,由于他们都是动态内置的结构,所以ArrayList是极好的实现选择。当需要往队列中插入数据项时,ArrayList会在表中把每一个保留的数据项向前移动一个元素。 class CQueue { private ArrayLis
来自:http://yingyingol.iteye.com/blog/13348911 快速排序介绍:快速排序是由东尼·霍尔所发展的一种排序算法。在平均状况下,排序 n 个项目要Ο(n log n)次比较。在最坏状况下则需要Ο(n2)次比较,但这种状况并不常见。事实上,快速排序通常明显比其他Ο(n log n) 算法更快,因为它的内部循环(inner loop)可以在大部分的架构上很有效率地
Stack的实现必须采用一种基本结构来保存数据。因为再新数据项进栈的时候不需要担心调整表的大小,所以选择用arrayList.using System;using System.Collections.Generic;using System.Linq;using System.Text;using System.Threading.Tasks;using System.Collecti
数组类测试环境与排序算法using System;using System.Collections.Generic;using System.Linq;using System.Text;using System.Threading.Tasks;namespace Data_structure_and_algorithm{ class CArray { pr
一、构造二叉树 二叉树查找树由节点组成,所以需要有个Node类,这个类类似于链表实现中用到的Node类。首先一起来看看Node类的代码。 public class Node { public int Data; public Node Left; public Node Right; public v
二叉树是一种特殊的树。二叉树的特点是每个结点最多有两个儿子,左边的叫做左儿子,右边的叫做右儿子,或者说每个结点最多有两棵子树。更加严格的递归定义是:二叉树要么为空,要么由根结点、左子树和右子树组成,而左子树和右子树分别是一棵二叉树。 下面这棵树就是一棵二叉树。         二叉树的使用范围最广,一棵多叉树也可以转化为二叉树,因此我们将着重讲解二叉树。二叉树中还有连两种特殊的二叉树叫做满二叉树和
上一节中我们学习了队列,它是一种先进先出的数据结构。还有一种是后进先出的数据结构它叫做栈。栈限定只能在一端进行插入和删除操作。比如说有一个小桶,小桶的直径只能放一个小球,我们现在向小桶内依次放入2号、1号、3号小球。假如你现在需要拿出2号小球,那就必须先将3号小球拿出,再拿出1号小球,最后才能将2号小球拿出来。在刚才取小球的过程中,我们最先放进去的小球最后才能拿出来,而最后放进去的小球却可以最先拿
msdn中的描述如下:(?= 子表达式)(零宽度正预测先行断言。) 仅当子表达式在此位置的右侧匹配时才继续匹配。例如,w+(?=d) 与后跟数字的单词匹配,而不与该数字匹配。此构造不会回溯。(?(零宽度正回顾后发断言。) 仅当子表达式在此位置的左侧匹配时才继续匹配。例如,(?此构造不会回溯。msdn描述的比较清楚,如:w+(?=ing) 可以匹配以ing结尾的单词(匹配结果不包括ing),(
1.引入线索二叉树 二叉树的遍历实质上是对一个非线性结构实现线性化的过程,使每一个节点(除第一个和最后一个外)在这些线性序列中有且仅有一个直接前驱和直接后继。但在二叉链表存储结构中,只能找到一个节点的左、右孩子信息,而不能直接得到节点在任一遍历序列中的前驱和后继信息。这些信息只有在遍历的动态过程中才能得到,因此,引入线索二叉树来保存这些从动态过程中得到的信息。 2.建立线索二叉树 为了保
排序与我们日常生活中息息相关,比如,我们要从电话簿中找到某个联系人首先会按照姓氏排序、买火车票会按照出发时间或者时长排序、买东西会按照销量或者好评度排序、查找文件会按照修改时间排序等等。在计算机程序设计中,排序和查找也是最基本的算法,很多其他的算法都是以排序算法为基础,在一般的数据处理或分析中,通常第一步就是进行排序,比如说二分查找,首先要对数据进行排序。在Donald Knuth 的计算机程序设