[数据结构] 哈希表

概念

冲突-概念

冲突-避免

冲突-避免-哈希函数设计

常见哈希函数

1.直接定制发--(常用)

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

3.平方取中法--(了解)

4.折叠法--(了解)

5.数学分析法--(了解)

冲突-避免-负载因子调节(重点掌握)

冲突-解决-闭散列

1.线性探测

2.二次探测

冲突-解决-开散列/哈希桶(重点掌握)

哈希冲突严重时的解决办法

实现

性能分析

概念

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

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

当向该结构中:

插入元素

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

搜索元素

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

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

例如: 数据集合{1 , 7 , 6 , 4 , 5 , 9 };

哈希函数设置为: hash(key) = key % capacity; capacity为存储元素底层空间总的大小

用该方法进行搜索不必进行多次关键码的比较, 因此搜索的速度比较快

问题: 按照上述哈希方式,向集合中插入元素44 , 或出现什么问题?

冲突-概念

对于两个数据元素的关键字和 (ki != kj)，有ki != kj ，但有：Hash( ki) == Hash( kj)，即: 不同关键字通过相同哈希函数计算出相同的哈希地址, 该种现象称为哈希冲突或哈希碰撞,

把具有不同关键码而具有相同哈希地址的数据元素称为 " 同义词".

冲突-避免

首先, 我们需要明确一点,由于我们哈希表底层数组的容量往往时小于实际要存储的关键字的数量的,这就导致一个问题, 冲突的发生时必然的, 但我们能做的应该时尽量的降低冲突率.

冲突-避免-哈希函数设计

引起哈希冲突的一个原因可能时: 哈希函数是设计不够合理. 哈希函数设计原则:

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

常见哈希函数

1.直接定制发--(常用)

取关键字的某个线性函数为散列地址: Hash(key) = A*Key + B 优点: 简单 , 均匀缺点: 需要事先知道关键字的分布情况使用场景 : 是适合查找比较小且连续的情况

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

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

3.平方取中法--(了解)

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

4.折叠法--(了解)

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

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

5.数学分析法--(了解)

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

假设要存储某家公司员工登记表，如果用手机号作为关键字，那么极有可能前7位都是相同的，那么我们可以选择后面的四位作为散列地址，如果这样的抽取工作还容易出现冲突，还可以对抽取出来的数字进行反转(如 1234 改成 4321)、右环位移(如 1234 改成 4123)、左环移位、前两数与后两数叠加(如 1234 改成 12+34=46)等方法。

数字分析法通常适合处理关键字位数比较大的情况，如果事先知道关键字的分布且关键字的若干位分布较均匀的情况

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

冲突-避免-负载因子调节(重点掌握)

散列表的载荷因子定义为：α = 填入表中的元素个数 / 散列表的长度

所以当冲突率达到一个无法忍受的程度时，我们需要通过降低负载因子来变相的降低冲突率。
已知哈希表中已有的关键字个数是不可变的，那我们能调整的就只有哈希表中的数组的大小。

α 是散列表装满程度的标志因子。由于表长是定值，α 与“填入表中的元素个数”成正比

所以，α 越大，表明填入表中的元素越多，产生冲突的可能性就越大
反之，α 越小，表明填入表中的元素越少，产生冲突的可能性就越小

实际上，散列表的平均查找长度是载荷因子 α 的函数，只是不同处理冲突的方法有不同的函数

对于开放定址发，载荷因子是特别重要的因素，应严格限制在 0.7-0.8 以下。超过 0.8，查表时 CPU 缓存不命中（cachemissing）按照指数曲线上升。因此，一些采用开放定址法的 hash 库，如 Java 的系统库限制了载荷因子为 0.75，超过此值将 resize 散列表

冲突-解决-闭散列

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

1.线性探测

比如上面的场景, 现在需要插入元素44, 先通过哈希函数计算哈希地址,下标为4,因此44理论上应该插在该位置,但是该位置已经放了值为4的元素,即发生哈希冲突.

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

插入

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

采用闭散列处理哈希冲突时,不能随便物理删除哈希表中已有的元素,若直接删除元素会影响其他元素的搜索.比如删除元素4,如果直接删除掉, 44查找起来可能会受影响.因此线性探测采用标记的伪删除法来删除一个元素.

2.二次探测

线性探测的缺点是产生冲突的数据堆积在一起, 这与其找下一个空位置有关系, 因为找空位置的方式就是挨着往后逐个去找, 因此二次探测为了避免该问题, 找下一个空位置的方法为: $H_{i} = (H_{0} + i^{2})$ %m,或者: $H_{i} = (H_{0} - i^{2})$ % m .其中, i = 1, 2, 3...,H0是通过散列函数Hash(x)对元素的关键码key进行计算得到的位置,m是表的大小.对于上面的插入44,产生冲突,使用解决后的情况为:

研究表明：当表的长度为质数且表装载因子a不超过0.5时，新的表项一定能够插入，而且任何一个位置都不会被探查两次。因此只要表中有一半的空位置，就不会存在表满的问题。在搜索时可以不考虑表装满的情况，但在插入时必须确保表的装载因子a不超过0.5，如果超出必须考虑增容。

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

冲突-解决-开散列/哈希桶(重点掌握)

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

从上图可以看出, 开散列中每个桶中放的都是发生哈希冲突的元素.

开散列, 可以认为是把一个在大集合中的搜索问题转化在小集合中做搜索了.

哈希冲突严重时的解决办法

刚才我们提到了，哈希桶其实可以看作将大集合的搜索问题转化为小集合的搜索问题了，那如果冲突严重，就意味着小集合的搜索性能其实也时不佳的，这个时候我们就可以将这个所谓的小集合搜索问题继续进行转化，例如：

1. 每个桶的背后是另一个哈希表

2. 每个桶的背后是一棵搜索树

实现

// key-value 模型
public class HashBucket {private static class Node {private int key;private int value;Node next;public Node(int key,int value) {this.key = key;this.value = value;}}private Node[] array;private int size; // 当前的数据个数private static final double LOAD_FACTOR = 0.75;private int put(int key,int value) {int index = key % array.length;// 在链表中查找key所在的节点// 如果找到了,更新// 所有节点都不是key, 插入一个新的节点for (Node cur =array[index];cur != null;cur = cur.next) {if(key == cur.key) {int oldValue = cur.value;cur.value = value;return oldValue;}}Node node = new Node(key,value);node.next = array[index];array[index] = node;size++;if (loadFactor() >= LOAD_FACTOR) {resize();}return -1;}private void resize() {Node[] newArray = new Node[array.length * 2];for (int i = 0;i < array.length;i++) {Node next;for(Node cur = array[i];cur != null;cur = next) {next = cur.next;int index = cur.key % newArray.length;cur.next = newArray[index];newArray[index] = cur;}}array = newArray;}private double loadFactor() {return size * 1.0 / array.length;}public HashBucket() {array = new Node[8];size = 0;}public int get(int key) {int index = key % array.length;Node head = array[index];for(Node cur = head;cur != null;cur = cur.next) {if(key == cur.key) {return cur.value;}}return -1;}}