数据结构-Java实现散列表

概念

散列表（Hash table，也叫哈希表），是根据关键码值(Key value)而直接进行访问的数据结构。也就是说，它通过把关键码值映射到表中一个位置来访问记录，以加快查找的速度。这个映射函数叫做散列函数，存放记录的数组叫做散列表。

给定表M，存在函数f(key)，对任意给定的关键字值key，代入函数后若能得到包含该关键字的记录在表中的地址，则称表M为哈希(Hash）表，函数f(key)为哈希(Hash) 函数。



本文使用除留取余hash算法，使用链地址法处理地址冲突，在java语言中实现散列表的数据接口

节点数据结构

package com.billJiang.hashtable;

/**
* Created by billJiang on 2016/11/30.
* hashtable 节点 可能发生碰撞
*/
public class Entry<T> {
int key;
T item;
Entry<T> next;

public Entry(int key,T item,Entry<T> next){
this.key=key;
this.item=item;
this.next=next;
}
}

实现代码

package com.billJiang.hashtable;

import java.util.Arrays;

/**
* Created by billJiang on 2016/11/30.
*/
public class HashTable<T> {
private static final int INITIAL_SIZE=3;
private static final float LOAD_FACTOR=0.75f;
private  Entry<T>[] table;

private int size=0;
private int use=0;

public HashTable() {
table = new Entry[INITIAL_SIZE];
}

public void put(int key,T item){
int index=hash(key);
if(table[index]==null){
table[index]=new Entry(-1,null,null);
}
Entry e=table[index];
//未存过值
if(e.next==null){
Entry entry=new Entry(key,item,null);
e.next=entry;
size++;
use++;
if(use>=table.length*LOAD_FACTOR){
resize();
}
}else{
//已经存在值，替换
for(e=e.next;e!=null;e=e.next){
if(e.key==key){
e.item=item;
return;
}
}
//追加
Entry temp=table[index].next;
Entry entry=new Entry(key,item,temp);
table[index].next=entry;
size++;
}

}

public void remove(int key){
int index=hash(key);
Entry e=table[index];
Entry pre=table[index];
for(e=e.next;e!=null;e=e.next){
if(e.key==key){
pre.next=e.next;
size--;
//TODO 24页缺少以下两行代码
if (pre.key == -1 && e.next == null)
use--;
break;
}
pre=e;
}

}

public T get(int key){
int index=hash(key);
Entry e=table[index];
for(e=e.next;e!=null;e=e.next){
if(e.key==key){
return (T) e.item;
}
}
return null;
}

public int size(){
return this.size;
}

public int getLength(){
return table.length;
}

private int hash(int key){
return key%table.length;
}

private void resize(){
Entry[] oldTable=table;
table=new Entry[table.length*2];
use=0;
for(int i=0;i<oldTable.length;i++){
if(oldTable[i]!=null&&oldTable[i].next!=null){
Entry e= oldTable[i];
Entry next=e.next;
while(e.next!=null){
int index=hash(next.key);
if(table[index]==null){
table[index]=new Entry(-1,null,null);
use++;
}
Entry temp=table[index].next;
table[index].next=new Entry(next.key,next.item,temp);
e=next;
}
}
}

}
}

测试代码

package com.billJiang.hashtable;

/**
* Created by billJiang on 2016/11/30.
*/
public class HashTableTest {

public static void main(String[] args) {
HashTable<String> table=new HashTable<String>();
table.put(1,"A");
table.put(2,"B");
table.put(3,"C");
table.put(4,"D");

table.put(5,"Hello world");

table.remove(1);

}
}

散列表的特点

访问速度很快

需要额外的空间

无序

可能发生碰撞

散列表经常用于缓存和快速查找。