哈希表
- 什么是哈希表
哈希表,又叫散列表,是根据关键码值(Key value)而直接进行访问的数据结构。也就是说,它通过把关键码值映射到表中一个位置来访问记录,以加快查找的速度。这个映射函数叫做散列函数,存放记录的数组叫做散列表。 - 哈希冲突的常用解决方法
链地址法(拉链法)
开放寻址法
再哈希法 - 具体实现代码(具体的细节问题看注释)
package HashTable;
import java.util.TreeMap;
/**
* @ Description: 哈希表的实现
* @ Date: Created in 11:16 24/07/2018
* @ Author: Anthony_Duan
*/
public class HashTable<K extends Comparable<K>, V> {
/**
* 哈希表的长度最好是素数并且原理2的幂,这样可以解决在模的结果中出现过多的哈希冲突
* 下面是一个素数表 最后一个接近int值的最大上限
*/
private final int[] capacity = {53, 97, 193, 389, 769, 1543, 3079, 6151, 12289, 24593,
49157, 98317, 196613, 393241, 786433, 1572869, 3145739, 6291469,
12582917, 25165843, 50331653, 100663319, 201326611, 402653189, 805306457, 1610612741};
private static final int upperTol = 10;
public static final int lowerTol = 2;
private int capacityIndex = 0;
private TreeMap<K, V>[] hashtable;
private int size;
private int M;
public HashTable() {
this.M = capacity[capacityIndex];
size = 0;
hashtable = new TreeMap[M];
for (int i = 0; i < M; i++) {
hashtable[i] = new TreeMap<>();
}
}
private int hash(K key) {
/**
* 0x7FFFFFFF is 0111 1111 1111 1111 1111 1111 1111 1111
* & 0x7fffffff 是为了让结果始终为正数 这样求模不会有错误
*/
return (key.hashCode() & 0x7fffffff) % M;
}
public int getSize() {
return size;
}
public void add(K key, V value) {
TreeMap<K, V> map = hashtable[hash(key)];
if (map.containsKey(key)) {
map.put(key, value);
} else {
map.put(key, value);
size++;
/**
* 如果冲突率过高 就扩容
* 这里 size >= upperTol * M 这种写法是为了避免除法
* 因为除法得出的结果为浮点型 在比较的时候整形会先转化为浮点型 这个操作其实是无用的
*/
if (size >= upperTol * M && capacityIndex + 1 < capacity.length) {
capacityIndex++;
resize(capacity[capacityIndex]);
}
}
}
private void resize(int newM) {
TreeMap<K, V>[] newHashTable = new TreeMap[newM];
for (int i = 0; i < newM; i++) {
newHashTable[i] = new TreeMap<>();
}
int oldM = M;
this.M = newM;
for (int i = 0; i < oldM; i++) {
TreeMap<K, V> map = hashtable[i];
for (K key :
map.keySet()) {
newHashTable[hash(key)].put(key, map.get(key));
}
}
this.hashtable = newHashTable;
}
public V remove(K key) {
V ret = null;
TreeMap<K, V> map = hashtable[hash(key)];
if (map.containsKey(key)) {
ret = map.remove(key);
size--;
if (size < lowerTol * M && capacityIndex - 1 >= 0) {
capacityIndex--;
resize(capacity[capacityIndex]);
}
}
return ret;
}
public void set(K key, V value) {
TreeMap<K, V> map = hashtable[hash(key)];
if (!map.containsKey(key)) {
throw new IllegalArgumentException(key + " doesn't exist!");
}
map.put(key, value);
}
public boolean contains(K key) {
return hashtable[hash(key)].containsKey(key);
}
public V get(K key) {
return hashtable[hash(key)].get(key);
}
}