散列表(Hash table,也叫哈希表),是根据关键码值(Key value)而直接进行访问的数据结构。也就是说,它通过把关键码值映射到表中一个位置来访问记录,以加快查找的速度。这个映射函数叫做散列函数,存放记录的数组叫做散列表。
给定表M,存在函数f(key),对任意给定的关键字值key,代入函数后若能得到包含该关键字的记录在表中的地址,则称表M为哈希(Hash)表,函数f(key)为哈希(Hash) 函数。
若关键字为k,则其值存放在f(k)的存储位置上。由此,不需比较便可直接取得所查记录。称这个对应关系f为散列函数,按这个思想建立的表为散列表。
对不同的关键字可能得到同一散列地址,即k1≠k2,而f(k1)=f(k2),这种现象称为冲突(英语:Collision)。具有相同函数值的关键字对该散列函数来说称做同义词。综上所述,根据散列函数f(k)和处理冲突的方法将一组关键字映射到一个有限的连续的地址集(区间)上,并以关键字在地址集中的“像”作为记录在表中的存储位置,这种表便称为散列表,这一映射过程称为散列造表或散列,所得的存储位置称散列地址。
若对于关键字集合中的任一个关键字,经散列函数映象到地址集合中任何一个地址的概率是相等的,则称此类散列函数为均匀散列函数(Uniform Hash function),这就是使关键字经过散列函数得到一个“随机的地址”,从而减少冲突。
反正我看着上面的感觉有点晕@-@
数组和链表相互结合,也就是数组访问,链表插入修改数据。比如在我刚学完链表时就设计出了这样一种结构基于数据对象id的byte值的个位数(0-9)创建了一个大小为10的数组,然后在这些数组后面放插入的数据,这个数据用链表进行保存(因为会有相同的)。这要每次查找的时候先找数组,再找到链表里面遍历id值相同的节点。(当然因为当时我刚学完链表,现在这个hash算法并不太合理...)。
这里我们将对象的id称之为key,取id的byte值的最后一位的个位数的操作称之为hash算法。
而这种通过对关键key(称之为“键”)和value(“值”)映射,利用数组的随机访问特性(更确切的说是利用桶的概念,将数据放在key对应的桶中),将key放到对应数组下标(基于hash算法),对数组内数据进行访问修改的线性数据结构就被称为hash映射表(所谓的映射:就是key和存储对象的关联,但二者不一定要真的有关系)。再简单点就是hash(key)等于数组下标,value为数组里面的值或值组成的链表(链表法)。
另外哈希表分为带key值的哈希映射表(如HashMap),和值不重复的哈希集合表(如HashSet)
其中最关键的几个地方在于:hash算法,散列冲突的处理。
实际工作中需视不同的情况采用不同的哈希函数,通常考虑的因素有:
· 计算哈希函数所需时间
· 关键字的长度
· 哈希表的大小
· 关键字的分布情况(尽量少的hash冲突)
· 记录的查找频率
常用的hash算法设计方法:
1.直接寻址法:取关键字或关键字的某个线性函数值为散列地址。
2.数字分析法(找规律):分析一组数据,比如一组员工的出生年月日,这时我们发现出生年月日的前几位数字大体相同,这样的话,出现冲突的几率就会很大,但是我们发现年月日的后几位表示月份和具体日期的数字差别很大,如果用后面的数字来构成散列地址,则冲突的几率会明显降低。因此数字分析法就是找出数字的规律,尽可能利用这些数据来构造冲突几率较低的散列地址。
3.平方取中法:当无法确定关键字中哪几位分布较均匀时,可以先求出关键字的平方值,然后按需要取平方值的中间几位作为哈希地址。这是因为:平方后中间几位和关键字中每一位都相关,故不同关键字会以较高的概率产生不同的哈希地址。
4.折叠法:将关键字分割成位数相同的几部分,最后一部分位数可以不同,然后取这几部分的叠加和(去除进位)作为散列地址。数位叠加可以有移位叠加和间界叠加两种方法。移位叠加是将分割后的每一部分的最低位对齐,然后相加;间界叠加是从一端向另一端沿分割界来回折叠,然后对齐相加。
5.随机数法:选择一随机函数,取关键字的随机值作为散列地址,即H(key)=random(key)其中random为随机函数,通常用于关键字长度不等的场合。
6.除留余数法(取模运算):取关键字被某个不大于散列表表长m的数p除后所得的余数为散列地址。即 H(key) = key MOD p,p<=m。不仅可以对关键字直接取模,也可在折叠、平方取中等运算之后取模。对p的选择很重要,一般取素数或m,若p选的不好,容易产生同义词。
常见的hash算法:MD5,SHA-1
其中最简单的当然就是取模 - -!在日常生活中我们计算时分秒,年月日都是用的这个办法。(比如:我们日常会说今天是2020年1月27日,而不是说今天是公元1234567890天...事实上当面对需要将大规模数据映射或限制到指定范围内时,首先想到的就应该是取模运算。比如我们可以把公元第任意天换成今天星期几...)
从hash算法本身就可以看出,将大数据压缩到固定大小必然会有两个key的hash相同的情况(今天周一,七天后也是周一)产生冲突。那么此时两个hash值相同的数据该怎么处理呢?
常用hash冲突解决方法:
当我们往散列表中插入数据时,如果某个数据经过散列函数散列之后,存储位置已经被占用了,我们就从当前位置开始,依次往后查找,看是否有空闲位置,直到找到为止。
在散列表中查找元素的过程有点儿类似插入过程。我们通过散列函数求出要查找元素的键值对应的散列值,然后比较数组中下标为散列值的元素和要查找的元素。如果相等,则说明就是我们要找的元素;否则就顺序往后依次查找。如果遍历到数组中的空闲位置,还没有找到,就说明要查找的元素并没有在散列表中。
你可能已经发现了,线性探测法其实存在很大问题。当散列表中插入的数据越来越多时,散列冲突发生的可能性就会越来越大,空闲位置会越来越少,线性探测的时间就会越来越久。极端情况下,我们可能需要探测整个散列表,所以最坏情况下的时间复杂度为 O(n)。同理,在删除和查找时,也有可能会线性探测整张散列表,才能找到要查找或者删除的数据。
2.二次探测
所谓二次探测,跟线性探测很像,线性探测每次探测的步长是 1,那它探测的下标序列就是 hash(key)+0,hash(key)+1,hash(key)+2……而二次探测探测的步长就变成了原来的“二次方”,也就是说,它探测的下标序列就是 hash(key)+0,hash(key)+12,hash(key)+22……
3.双重散列
双重散列就是不仅要使用一个散列函数。我们使用一组散列函数 hash1(key),hash2(key),hash3(key)……我们先用第一个散列函数,如果计算得到的存储位置已经被占用,再用第二个散列函数,依次类推,直到找到空闲的存储位置。不管采用哪种探测方法,当散列表中空闲位置不多的时候,散列冲突的概率就会大大提高。为了尽可能保证散列表的操作效率,一般情况下,我们会尽可能保证散列表中有一定比例的空闲槽位。我们用装载因子(load factor)来表示空位的多少。
装载因子的计算公式是:散列表的装载因子=填入表中的元素个数/散列表的长度
装载因子越大,说明空闲位置越少,冲突越多,散列表的性能会下降。
但是当hash冲突较多时,链表会急剧扩大,导致最后下降成O(n)。所以在如:Java的HashMap中为了进行优化,链表长度大于8时,会将链表自动转换为红黑树(红黑色见后面平衡二叉树相关内容)。默认16的数组,当装载因子大于0.75时也就是大于12占用就自动扩容,为什么是0.75呢?自己去看hashmap源码,里面注释写的:
在理想情况下,使用随机哈希码,节点出现的频率在hash桶中遵循泊松分布,同时注释里面给出了桶中元素个数和概率的对照表。
从表里面可以看到当桶中元素到达8个的时候,概率已经变得非常小,也就是说用0.75作为加载因子,每个碰撞位置的链表长度超过8个是几乎不可能的。
“松柏分布”(即单位时间内独立事件发生次数的概率分布)...瞬间感觉高大上⊙﹏⊙感兴趣的可以自行了解这里就不往统计学里面讲了(统计学相关请期待:后面可能会加的数学统计学相关的内容)
另外在.net中的hashtable是0.7(虽然官方说是1.0)
攻击的原理很简单, 目前很多语言, 使用hash来存储k-v数据, 包括常用的来自用户的POST数据, 攻击者可以通过构造请求头, 并伴随POST大量的特殊的”k”值(根据每个语言的Hash算法不同而定制), 使得语言底层保存POST数据的Hash表因为”冲突”(碰撞)而退化成链表.
另外随着RESTful风格的接口普及,程序员默认都会使用json作为数据传递的方式。json格式的数据冗余少,兼容性高,从提出到现在已被广泛的使用,可以说成为了Web的一种标准。无论我们服务端使用什么语言,我们拿到json格式的数据之后都需要做jsonDecode(),将json串转换为json对象,而对象默认会存储于Hash Table,而Hash Table很容易被碰撞攻击。我只要将攻击数据放在json中,服务端程序在做jsonDecode()时必定中招,中招后CPU会立刻飙升至100%。16核的CPU,16个请求就能达到DoS的目的。
感兴趣的自行了解
/**
* @Description:散列表实现
* @Author: Hoda
* @Date: Create in 2019-08-07
* @Modified By:
* @Modified Date:
*/
public class HashTable<K, V> {
/**
* 散列表默认长度
*/
private static final int DEFAULT_INITAL_CAPACITY = 8;
/**
* 装载因子
*/
private static final float LOAD_FACTOR = 0.75f;
/**
* 初始化散列表数组
*/
private Entry<K, V>[] table;
/**
* 实际元素数量
*/
private int size = 0;
/**
* 散列表索引数量
*/
private int use = 0;
public HashTable() {
table = (Entry<K, V>[]) new Entry[DEFAULT_INITAL_CAPACITY];
}
static class Entry<K, V> {
K key;
V value;
Entry<K, V> next;
Entry(K key, V value, Entry<K, V> next) {
this.key = key;
this.value = value;
this.next = next;
}
}
/**
* 新增
*
* @param key
* @param value
*/
public void put(K key, V value) {
int index = hash(key);
// 位置未被引用,创建哨兵节点
if (table[index] == null) {
table[index] = new Entry<>(null, null, null);
}
Entry<K, V> tmp = table[index];
// 新增节点
if (tmp.next == null) {
tmp.next = new Entry<>(key, value, null);
size++;
use++;
// 动态扩容
if (use >= table.length * LOAD_FACTOR) {
resize();
}
}
// 解决散列冲突,使用链表法
else {
do {
tmp = tmp.next;
// key相同,覆盖旧的数据
if (tmp.key == key) {
tmp.value = value;
return;
}
} while (tmp.next != null);
Entry<K, V> temp = table[index].next;
table[index].next = new Entry<>(key, value, temp);
size++;
}
}
/**
* 散列函数
* <p>
* 参考hashmap散列函数
*
* @param key
* @return
*/
private int hash(Object key) {
int h;
return (key == null) ? 0 : ((h = key.hashCode()) ^ (h >>> 16)) % table.length;
}
/**
* 扩容
*/
private void resize() {
Entry<K, V>[] oldTable = table;
table = (Entry<K, V>[]) new Entry[table.length * 2];
use = 0;
for (int i = 0; i < oldTable.length; i++) {
if (oldTable[i] == null || oldTable[i].next == null) {
continue;
}
Entry<K, V> e = oldTable[i];
while (e.next != null) {
e = e.next;
int index = hash(e.key);
if (table[index] == null) {
use++;
// 创建哨兵节点
table[index] = new Entry<>(null, null, null);
}
table[index].next = new Entry<>(e.key, e.value, table[index].next);
}
}
}
/**
* 删除
*
* @param key
*/
public void remove(K key) {
int index = hash(key);
Entry e = table[index];
if (e == null || e.next == null) {
return;
}
Entry pre;
Entry<K, V> headNode = table[index];
do {
pre = e;
e = e.next;
if (key == e.key) {
pre.next = e.next;
size--;
if (headNode.next == null) use--;
return;
}
} while (e.next != null);
}
/**
* 获取
*
* @param key
* @return
*/
public V get(K key) {
int index = hash(key);
Entry<K, V> e = table[index];
if (e == null || e.next == null) {
return null;
}
while (e.next != null) {
e = e.next;
if (key == e.key) {
return e.value;
}
}
return null;
}
}
基础题:
1.给定一个整数数组,判断是否存在重复元素。
如果任何值在数组中出现至少两次,函数返回 true。如果数组中每个元素都不相同,则返回 false。
示例 1:
输入: [1,2,3,1]
输出: true
示例 2:
输入: [1,2,3,4]
输出: false
示例 3:
输入: [1,1,1,3,3,4,3,2,4,2]
输出: true
来源:力扣(LeetCode)217题
public boolean containsDuplicate(int[] nums) {
Set<Integer> set = new HashSet<>(nums.length);
for (int x: nums) {
if (set.contains(x)) return true;
set.add(x);
}
return false;
}
2.给定两个整数,分别表示分数的分子 numerator 和分母 denominator,以字符串形式返回小数。
如果小数部分为循环小数,则将循环的部分括在括号内。
示例 1:
输入: numerator = 1, denominator = 2
输出: "0.5"
示例 2:
输入: numerator = 2, denominator = 1
输出: "2"
示例 3:
输入: numerator = 2, denominator = 3
输出: "0.(6)"
来源:力扣(LeetCode)166题
public String fractionToDecimal(int numerator, int denominator) {
if (numerator == 0) {
return "0";
}
StringBuilder fraction = new StringBuilder();
// If either one is negative (not both)
if (numerator < 0 ^ denominator < 0) {
fraction.append("-");
}
// Convert to Long or else abs(-2147483648) overflows
long dividend = Math.abs(Long.valueOf(numerator));
long divisor = Math.abs(Long.valueOf(denominator));
fraction.append(String.valueOf(dividend / divisor));
long remainder = dividend % divisor;
if (remainder == 0) {
return fraction.toString();
}
fraction.append(".");
Map<Long, Integer> map = new HashMap<>();
while (remainder != 0) {
if (map.containsKey(remainder)) {
fraction.insert(map.get(remainder), "(");
fraction.append(")");
break;
}
map.put(remainder, fraction.length());
remainder *= 10;
fraction.append(String.valueOf(remainder / divisor));
remainder %= divisor;
}
return fraction.toString();
}
本文由 寻非 创作,如果您觉得本文不错,请随意赞赏
采用 知识共享署名4.0 国际许可协议进行许可
本站文章除注明转载/出处外,均为本站原创或翻译,转载前请务必署名
原文链接:https://www.zhouning.group/archives/数据结构基础07线性数据结构之hash表
最后更新:2020-01-28 22:06:13
Update your browser to view this website correctly. Update my browser now