数据结构——哈希

一、哈希概念

引入:

        顺序结构以及平衡树中,元素关键码与其存储位置之间没有对应关系,因此在查找一个元素时,必须要经过关键码的多次比较。其中顺序查找的时间复杂度为O(N),平衡树中为树的高度,即O(log_{2}^{N}),搜索的效率取决于搜索过程中元素的比较次数。

理想的搜索方法:

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

插入元素:

        根据待插入元素的关键码,以此函数计算出该元素的存储位置并按此位置进行存放。

搜索元素:

        对元素的关键码进行同样的计算,把求得的函数值当做元素的存储位置,在结构中按此位置取元素进行比较,若关键码相等,则搜索成功。

哈希(散列)方法:

        以上方式即为哈希方法,哈希方法中使用的转换函数称为哈希(散列)函数,构造出来的结构称为哈希表(Hash Table),或称为散列表。

二、哈希冲突(哈希碰撞)

1.概念

        不同的关键字通过相同的哈希函数计算出了相同的哈希地址,这种现象就称为哈希冲突或哈希碰撞。

2.哈希函数

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

2.1哈希函数设计原则

(1)哈希函数的定义域必须包括需要存储的全部关键字,如果散列表允许有m个地址时,其值域必须在0到m-1之间;

(2)函数函数计算出的哈希地址能够均匀分布在整个空间内;

(3)哈希函数设计应该尽可能简单。

2.2常见哈希函数

(1)直接定制法(常用)

取关键字的某个线性函数为散列地址:Hash(key) =A*key+B。

优点:简单、均匀;

缺点:需要事先知道关键字的分布情况。

使用场景:适合查找数据量比较小,且连续的情况。

(2)除留余数法(常用)

        假设散列表中允许的地址数为m,取一个不大于m,但接近或等于m的质数p作为除数,按照哈希函数:Hash(key)=key%p(p<=m),将关键码转换成哈希地址。

(3)平方取中法

        假设关键字为1234,对它进行平方为1522756,抽取中间三位227作为哈希地址。平方取中法比较适合:不知道关键字的分布,而位数又不是很大的情况。

(4)折叠法

        折叠法是将关键字从左到右分割成位数相等的几部分(最后一部分位数可以不足),然后将这几部分叠加求和,并按散列表表长,取后几位作为散列地址。

        折叠法适合事先不需要知道关键字分布,和关键字位数比较多的情况。

(5)随机数法

        选择一个随机函数,取关键字的随机函数值作为哈希地址:Hash(key)=random(key),其中random为随机数函数。

        随机数法通常用于关键字长度不等的情况。

(6)数学分析法

        假设有n个d位数,每一位可能有r种不同的符号,这r种不同的符号在各位上出现的频率不一定相同,可能在某些位上分布比较均匀,每种符号出现的机会均等,在某些位上分布不均匀只有几种符号经常出现。就可根据散列表的大小,选择其中各种符号分布均匀的若干位作为散列地址。

        数学分析法通常适合出来关键字位数比较大的情况,且事先知道关键字的分布且关键字的若干位分布较均匀的情况。

注意:哈希函数设计的越精妙,产生哈希冲突的机率就越低,但是无法完全避免。

三、哈希冲突解决方法

1. 闭散列(开放地址法)

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

闭散列:也叫开放地址法,当发生哈希冲突时,如果哈希表未被装满,那么可以把key存放到冲突位置的“下一个"空位置中去。那么如何查找下一个空位置?

1.1 线性探测

原理:

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

插入:

        通过哈希函数获取待插入元素在哈希表中的位置,如果该位置中没有元素则直接插入元素;如果该位置中已有元素发生哈希冲突,则使用线性探测找到下一个空位置,再插入元素。

删除:

        采用闭散列处理哈希冲突时,不能随便物理删除哈希表中已有的元素,若直接删除元素会影响到其他元素的搜索。比如两个关键字的哈希地址相同,一个通过线性探测插入到了后面的空位置,若直接删除前面的关键字,则会影响到后面关键字的搜索。

        因此线性探测采用标记的伪删除方式,来删除一个元素。

优点:实现简单

缺点:一旦发生哈希冲突,冲突的元素连在一起,容易产生数据堆积,即:不同的关键码占据了可利用的空位置,使得寻找某关键码的位置需要多次比较,导致搜索效率降低。

负载因子(载荷因子)=有效元素个数/表格容量

线性探测法的负载因子:一般控制在0.7左右。

1.2 二次探测

原理:

        线性探测的缺陷是产生冲突的数据容易堆积在一起,这与其查找下一个空位置的方式为往后逐个探测有关系,因此二次探测为了避免该问题,找下一个空位置的方法为:H_{i}=(H_{0}+i^{2})%m,或者:H_{i}=(H_{0}-i^{2})%m,其中i=1,2,3……,H_{0}是通过哈希函数对元素的关键码key进行计算得到的位置,m是哈希表的大小。

注意:

        研究表明:当表的长度为质数且负载因子不超过0.5时,新的表项一定能够插入,且任何一个位置都不会被探测两次,因此只要表项中有一半的空位置,就不会存在表满的问题。

        所以二次探测法,在搜索时可以不考虑表装满的情况,但是在插入时必须确保负载因子不超过0.5,超出则需要考虑扩容。

2.开散列(链地址法)

2.1 开散列概念

        开散列法又叫链地址法(开链法),其思想是:首先对关键码集合用哈希函数计算哈希地址,具有相同地址的关键码归于同一子集合,每一个子集合称为一个桶,各个桶中的元素通过一个单链表链接起来,各链表的头结点存储在哈希表中。

2.2 开散列的实现

HashBucket.hpp:

#pragma once
#include 
#include "Common.h"
//桶内链表节点
template
struct HashBucketNode {
	HashBucketNode* _next;
	T _value;
	HashBucketNode(const T& value = T())
		: _next(nullptr)
		, _value(value)
	{}
};

template>
class HashBucket {
	typedef HashBucketNode Node;
public:
	HashBucket(size_t initCapacity = 10) 
		: _table(GetNextPrime(initCapacity))
		, _size(0)
	{}
	//插入元素
	//1.不能存放重复元素
	bool InsertUnique(const T& value) {
		CheckCapacity();
		//①计算哈希地址--桶号
		size_t bucket = HashFunction(value);
		//②在bucket对应的桶内查找是否已经存在元素value
		Node* cur = _table[bucket];
		while (cur) {
			if (cur->_value == value) {
				return false;
			}
			cur = cur->_next;
		}
		//③插入新节点
		cur = new Node(value);
		cur->_next = _table[bucket];
		_table[bucket] = cur;
		++_size;
		return true;
	}
	//2.可以存放重复元素
	bool InsertEqual(const T& value) {
		CheckCapacity();
		//①计算哈希地址--桶号
		size_t bucket = HashFunction(value);
		//②插入新节点
		Node* cur = new Node(value);
		cur->_next = _table[bucket];
		_table[bucket] = cur;
		++_size;
		return true;
	}

	//删除
	//1.不能存放重复元素
	bool EraseUnique(const T& value) {
		//①计算哈希地址--桶号
		size_t bucket = HashFunction(value);
		//②在bucket对应的桶内查找元素value
		Node* cur = _table[bucket];
		Node* prev = nullptr;
		while (cur) {
			if (cur->_value == value) {
				if (nullptr == prev) {//元素为链表的第一个节点
					_table[bucket] = cur->_next;
					delete cur;
				}
				else {
					prev->_next = cur->_next;
					delete cur;
				}
				--_size;
				return true;
			}
			else {
				prev = cur;
				cur = cur->_next;
			}
		}
		return false;
	}
	//2.可以存放重复元素
	bool EraseEqual(const T& value) {
		size_t oldSize = _size;
		//①计算哈希地址--桶号
		size_t bucket = HashFunction(value);
		//②在bucket对应的桶内查找元素value
		Node* cur = _table[bucket];
		Node* prev = nullptr;
		while (cur) {
			if (cur->_value == value) {
				if (nullptr == prev) {//元素为链表的第一个节点
					_table[bucket] = cur->_next;
					delete cur;
					cur = _table[bucket];
				}
				else {
					prev->_next = cur->_next;
					delete cur;
					cur = prev->_next;
				}
				--_size;
			}
			else {
				prev = cur;
				cur = cur->_next;
			}
		}
		return oldSize != _size;
	}

	//查找
	Node* Find(const T& value) {
		//①计算哈希地址--桶号
		size_t bucket = HashFunction(value);
		//②在bucket对应的桶内查找元素value
		Node* cur = _table[bucket];
		while (cur) {
			if (cur->_value == value) {
				return cur;
			}
			cur = cur->_next;
		}
		return nullptr;
	}

	//容量
	size_t Size() const {
		return _size;
	}

	//测试函数:打印每个桶内元素
	void PrintBucket() {
		for (size_t i = 0; i < _table.capacity(); ++i) {
			std::cout << "table[" << i << "]: ";
			Node* cur = _table[i];
			while (cur) {
				std::cout << cur->_value << "-->";
				cur = cur->_next;
			}
			std::cout << "NULL" << std::endl;
		} 
	}
private:
	size_t HashFunction(const T& value) {//哈希函数
		T2INT t2int;
		return t2int(value) % _table.capacity();
	}
	size_t HashFunction(const T& value, size_t capacity) {//哈希函数
		T2INT t2int;
		return t2int(value) % capacity;
	}

	void CheckCapacity() {//检测扩容
		if (_size == _table.capacity()) {
			//1.申请新空间
			std::vector newTable(GetNextPrime(_table.capacity()));
			//2.拷贝元素:将每个桶内的元素搬移到新桶中
			for (size_t i = 0; i < _table.capacity(); ++i) {
				Node* cur = _table[i];
				while (cur) {
					//将节点从链表上拆下来
					_table[i] = cur->_next;
					//散列到新桶中
					size_t newBucket = HashFunction(cur->_value, newTable.capacity());
					cur->_next = newTable[newBucket];
					newTable[newBucket] = cur;
					//取旧桶内的下一个节点
					cur = _table[i];
				}
			}
			//3.
			_table.swap(newTable);
		}
	}

private:
	std::vector _table;//哈希表
	size_t _size;//有效元素个数
};

Common.h:

#pragma once
//将类型转换为整形
#include 
template
class T2INT {//int
public:
	size_t operator()(const T& data) {
		return data;
	}
};

class Str2INT {//string
public:
	size_t operator()(const std::string& str) {
		return SDBMHash(str.c_str());
	}

	unsigned int SDBMHash(const char* str) {
		unsigned int hash = 0;
		unsigned int seed = 131;
		while (*str) {
			hash = hash * seed + (*str++);
		}
		return (hash & 0x7FFFFFFF);
	}
};

//增容质数表
const int PRIMECOUNT = 31;
const size_t primeList[PRIMECOUNT] =
{
 5,11, 23,
 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 GetNextPrime(size_t prime) {
	for (size_t i = 0; i < PRIMECOUNT; ++i) {
		if (primeList[i] > prime) {
			return primeList[i];
		}
	}
	return primeList[PRIMECOUNT - 1];
}

你可能感兴趣的:(数据结构,数据结构,哈希算法)