1.前言
我们前面学习了二叉搜索树的相关操作、Map和Set的使用，今天继续跟大家分享数据结构中的哈希表相关知识，让我们一起进入数据结构的世界，探索哈希表的奥秘！
2.哈希表
2.1概念
顺序结构以及平衡树中，元素关键码与其存储位置之间没有对应的关系，因此在查找一个元素时，必须要经过关键码的多次比较。顺序查找时间复杂度为O(N)，平衡树中为树的高度，即O(log₂N)，搜索的效率取决于搜索过程中元素的比较次数。
理想的搜索方法：可以不经过任何比较，一次直接从表中得到要搜索的元素。 如果构造一种存储结构，通过某种函数(hashFunc)使元素的存储位置与它的关键码之间能够建立一一映射的关系，那么在查找时通过该函数可以很快找到该元素。
当向该结构中：
- 插入元素
根据待插入元素的关键码，以此函数计算出该元素的存储位置并按此位置进行存放。
- 搜索元素
用该方法进行搜索不必进行多次关键码的比较，因此搜索的速度比较快。
2.2冲突-概念
对于两个数据元素的关键字 ki 和 k(j)，有ki != kj，但有：Hash(ki) == Hash(kj)，即：不同关键字通过相同哈希函数计算出相同的哈希地址，该现象称为哈希冲突或哈希碰撞。
因此我们把具有不同关键码而具有相同哈希地址的数据元素称为“同义词”。
2.3冲突-避免
2.3.1哈希函数设计
引起哈希冲突的一个原因可能是：哈希函数设计不够合理。哈希函数设计原则：
- 哈希函数的定义域必须包括需要存储的全部关键码，而如果散列表允许有m个地址时，其值域必须在0到m-1之间。
- 哈希函数计算出来的地址能均匀分布在整个空间中
- 哈希函数应该比较简单。
常见哈希函数
1.直接定制法
class Solution {
public int firstUniqChar(String s) {
int[] arr =new int[26];
for(int i = 0;i<s.length();i++){
char ch = s.charAt(i);
arr[ch-'a']++;
}
for(int i = 0;i<s.length();i++){
char ch = s.charAt(i);
if (arr[ch - 'a'] == 1) {
return i;
}
}
return-1;
}
}
2.3.2负载因子调节
负载因子和冲突率的关系粗略演示
2.4冲突-解决
2.4.1闭散列
闭散列：也叫开放定址法，当发生哈希冲突时，如果哈希表未被装满，说明在哈希表中必然还有空位置，那么可以把key存放到冲突位置中的“下一个” 空位置中去。那么如何寻找下一个空位置呢？
1.线性探测
线性探测：从发生冲突的位置开始，依次向后探测，直到寻找到下一个空位置为止。
插入：
- 通过哈希函数获取待插入元素在哈希表中的位置；
- 如果该位置中没有元素则直接插入新元素，如果该位置中有元素发生哈希冲突，使用线性探测找到下一个空位置，插入新元素。
采用闭散列处理哈希冲突时，不能随便物理删除哈希表中已有的元素，若直接删除元素会影响其他元素的搜索。比如删除元素4，如果直接删除掉，44查找起来可能会受影响。因此线性探测采用标记的伪删除法来删除一个元素。
2. 二次探测
线性探测的缺陷是产生冲突的数据堆积在一块，这与其找下一个空位置有关系，因为找空位置的方式就是挨着往后去找，因此二次探测为了避免该问题，找下一个空位置的方法为：Hi = (H0 + i²) % m，或者：Hi = (H0 - i²) % m。其中：i = 1，2，3…，H0是通过散列函数Hash(x)对元素的关键码key进行计算得到的位置，m是表的大小。
2.4.2开散列/哈希桶
public class HashBuck {
//哈希桶
static class Node {
public int key;
public int val;
public Node next;
public Node(int key, int val) {
this.key = key;
this.val = val;
}
}
public Node[] arr;
public int usedSize;
public double loadFactorCount = 0.75;
public HashBuck() {
arr = new Node[10];
}
public void put(int key, int val) {
int index = key % arr.length;
Node cur = arr[index];
//1.遍历当前链表，是否存在当前值
while (cur != null) {
if (cur.key == key) {
cur.val = val;
return;
}
cur = cur.next;
}
//2.说明没有当前值，此时进行头插
Node node = new Node(key, val);
node.next = arr[index];
arr[index] = node;
usedSize++;
//3.超过负载因子0.75进行扩容
if (loadFactorCount() >= loadFactorCount) {
//对数组进行扩容
resize();
}
}
private void resize() {
Node[] arr1 = new Node[arr.length * 2];
for (int i = 0; i < arr.length; i++) {
Node cur = arr[i];
//开始遍历链表
while (cur != null) {
int index1 = cur.key % arr1.length;
//把数据存放在新数组arr1位置
Node cur1 = cur.next;
cur.next = arr1[index1];
arr1[index1] = cur;
cur = cur1;
}
}
arr = arr1;
}
private double loadFactorCount() {
return usedSize * 1.0 / arr.length;
}
public int get(int key) {
int index = key % arr.length;
Node cur = arr[index];
while (cur != null) {
if (cur.key == key) {
return cur.val;
}
cur = cur.next;
}
return -1;
}
}
public class Test {
public static void main(String[] args) {
HashBuck hashBuck = new HashBuck();
hashBuck.put(1,20);
hashBuck.put(14,22);
hashBuck.put(8,11);
hashBuck.put(6,99);
hashBuck.put(9,41);
System.out.println(hashBuck.get(8));
}
}
2.5性能分析
3.哈希表和 java 类集的关系
1. HashMap 和 HashSet 即 java 中利用哈希表实现的 Map 和 Set
2. java 中使用的是哈希桶方式解决冲突的
3. java 会在冲突链表长度大于一定阈值后，将链表转变为搜索树（红黑树）
4..总结
哈希表是一种高效的数据结构，它通过哈希函数将元素的关键码映射到存储位置，以实现快速搜索、插入和删除操作。为了避免哈希冲突，我们可以通过设计合理的哈希函数、调整负载因子和解决冲突来降低冲突率，常见的哈希函数有直接定制法、除留余数法和平方取中法，以上就是本次所介绍的内容，我们下次再见。
1175
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
