目录
一、哈希表概念
哈希表是算法领域一种典型的以时间换空间的数据结构，设计哈希表最主要需要考虑两个问题：
一个是哈希函数的设计
再一个是如何避免哈希冲突
二、哈希函数的设计：
1.对数据转换成正整数，再对这个数取模运算
（1）一般会选择模一个素数，这样可以使得哈希表中元素分布更加均匀
（2）系统的hashcode函数对负数也是返回负数，可以通过&0x7fffffff来保证为正数
（3）这种方法对大证书、小数、字符串等都适用
1.字符串的处理
3.自定义类型需要重写Object类中的hashcode和equls
假设类型为：
（1）hashcode可以采用如下类似的这种方法：
其中B是代表自定义的进制数。
（2）equls重写分四步：
（2.1）if(this == o) return true;
（2.2）if(o == null) return false;
（2.3）if(getClass() != o.getClass()) return false;
（2.4）强制类型转换，并比较每一个成员变量是否相等
三、哈希冲突如何避免？
1.通过重写equls可以在哈希冲突时判断当前元素和已有元素是否真的相等？
（相同元素的哈希值一定相等，但是相同哈希值的元素不一定相等）
2.目前比较广泛的处理哈希冲突的办法——链地址法
即在产生哈希冲突的时候，后面来的元素直接插入链表的头部进行存储，保证不同元素的共容。
3.在java8之后，当平均容忍度超过8时，会自动转为红黑树
4.哈希冲突的其他处理方法：开放地址法、再哈希法、Colasced Hashing
四、设计自己的哈希表1（静态）
import java.util.TreeMap;
// 基于JAVA底层红黑树实现的哈希表
public class HashTable<K, V> {
private TreeMap<K, V>[] hashtable;
private int size; //数量
private int M; //容量
public HashTable(int M){
this.M = M;
size = 0;
hashtable = new TreeMap[M];
for(int i = 0 ; i < M ; i ++)
hashtable[i] = new TreeMap<>();
}
//默认初始化，设置为一个素数97
public HashTable(){
this(97);
}
private int hash(K key){
// 此处& 0x7fffffff表示取正数 ， 和31位1&，表示最高位一定是0，低31保持不变
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 ++;
}
}
//删
public V remove(K key){
V ret = null;
TreeMap<K, V> map = hashtable[hash(key)];
if(map.containsKey(key)){
ret = map.remove(key);
size --; //时刻记得维护size
}
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);
}
}五、设计自己的哈希表2（动态）
import java.util.Map;
import java.util.TreeMap;
public class HashTable<K, V> {
private static final int upperTol = 10; //最高容限因子
private static final int lowerTol = 2; //最低容限因子
private static final int initCapacity = 7; //初始化容量
private TreeMap<K, V>[] hashtable;
private int size;
private int M;
//如果用户传入了容量，则按照这个容量初始化
public HashTable(int M){
this.M = M;
size = 0;
hashtable = new TreeMap[M];
for(int i = 0 ; i < M ; i ++)
hashtable[i] = new TreeMap<>();
}
//如果用户没有初始化容量，则按照默认初始容量进行初始化
public HashTable(){
this(initCapacity);
}
private int hash(K key){
// 此处& 0x7fffffff表示取正数 ， 和31位1&，表示最高位一定是0，低31保持不变
return (key.hashCode() & 0x7fffffff) % M;
}
//此处添加了resize操作
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)
resize(2 * M);
}
}
//此处添加了resize操作
public V remove(K key){
V ret = null;
TreeMap<K, V> map = hashtable[hash(key)];
if(map.containsKey(key)){
ret = map.remove(key);
size --;
//特别注意M / 2 >= initCapacity，保证最小容量也要是7
if(size < lowerTol * M && M / 2 >= initCapacity)
resize(M / 2);
}
return ret;
}
// int oldM = M;this.M = newM;可以避免自己设计的hash方法出现Bug，因为里面引用了M
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;
}
}
六、设计自己的哈希表2：使用合理的hash容量
import java.util.TreeMap;
public class HashTable<K extends Comparable<K>, V> {
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;
private 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){
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 ++;
if(size >= upperTol * M && capacityIndex + 1 < capacity.length){
capacityIndex ++;
resize(capacity[capacityIndex]);
}
}
}
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);
}
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;
}
}
897
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
