Loading

JAVA数据结构--哈希表的实现（分离链接法）

哈希表（散列）的定义

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

哈希表的特点是采用以常数平均时间执行插入、删除和查找。

一个通俗的例子是，为了查找电话簿中某人的号码，可以创建一个按照人名首字母顺序排列的表（即建立人名x到首字母F(x)的一个函数关系），在首字母为W的表中查找“王”姓的电话号码，显然比直接查找就要快得多。这里使用人名作为关键字，“取首字母”是这个例子中散列函数的函数法则F()，存放首字母的表对应散列表。关键字和函数法则理论上可以任意确定。

分离链接法定义

将散列到同一个值得所有元素保留到一个表中。

基本思想是采用N个链表组成链表数组，N为哈希表的长度。

哈希表构造实现

1 public SeparateChainingHashTable() {
2         this(DEFAULT_TABLE_SIZE);
3     }
4 public SeparateChainingHashTable(int size) {
5     theLists=new LinkedList[nextPrime(size)];
6     for(int i=0;i<theLists.length;i++) {
7         theLists[i]=new LinkedList<>();//初始化链表数组
8     }
9 }

基本操作实现

 1 /*
 2      * 哈希表插入元素
 3      * */
 4     public void insert(T x) {
 5         List<T> whichList=theLists[myhash(x)];
 6         /*
 7          * 如果当前哈希地址的链表不含有元素，则链表中添加该元素
 8          * */
 9         if(!whichList.contains(x)) {
10             whichList.add(x);
11             if(++currentSize>theLists.length)//如果表长度不够，则扩容
12                 rehash();
13         }
14     }
15     public void remove(T x) {
16         List<T> whichList=theLists[myhash(x)];
17         if(whichList.contains(x)) {
18             whichList.remove(x);
19             currentSize--;
20         }
21     }
22     public boolean contains(T x) {
23         List<T> whilchList=theLists[myhash(x)];
24         return whilchList.contains(x);
25     }
26     public void makeEmpty() {
27         for(int i=0;i<theLists.length;i++)
28             theLists[i].clear();
29         currentSize=0;
30     }

哈希表相关实现

 1 private void rehash() {
 2         List<T>[] oldLists=theLists;
 3         theLists=new List[nextPrime(2*theLists.length)];
 4         for(int j=0;j<theLists.length;j++)
 5             theLists[j]=new LinkedList<>();
 6         
 7         currentSize=0;
 8         /*
 9          * 更新哈希表
10          * */
11         for(List<T> list:oldLists)
12             for(T item:list)
13                 insert(item);
14     }
15     /*
16      * myhash()方法获得哈希表的地址
17      * */
18     private int myhash(T x) {
19         int hashVal=x.hashCode();//hashCode()方法返回该对象的哈希码值
20         hashVal%=theLists.length;//对哈希表长度取余数
21         if(hashVal<0)
22             hashVal+=theLists.length;
23         return hashVal;
24     }

全部代码

  1 import java.util.LinkedList;
  2 import java.util.List;
  3 
  4 public class SeparateChainingHashTable<T>{
  5     public SeparateChainingHashTable() {
  6         this(DEFAULT_TABLE_SIZE);
  7     }
  8     public SeparateChainingHashTable(int size) {
  9         theLists=new LinkedList[nextPrime(size)];
 10         for(int i=0;i<theLists.length;i++) {
 11             theLists[i]=new LinkedList<>();//初始化链表数组
 12         }
 13     }
 14     
 15     /*
 16      * 哈希表插入元素
 17      * */
 18     public void insert(T x) {
 19         List<T> whichList=theLists[myhash(x)];
 20         /*
 21          * 如果当前哈希地址的链表不含有元素，则链表中添加该元素
 22          * */
 23         if(!whichList.contains(x)) {
 24             whichList.add(x);
 25             if(++currentSize>theLists.length)//如果表长度不够，则扩容
 26                 rehash();
 27         }
 28     }
 29     public void remove(T x) {
 30         List<T> whichList=theLists[myhash(x)];
 31         if(whichList.contains(x)) {
 32             whichList.remove(x);
 33             currentSize--;
 34         }
 35     }
 36     public boolean contains(T x) {
 37         List<T> whilchList=theLists[myhash(x)];
 38         return whilchList.contains(x);
 39     }
 40     public void makeEmpty() {
 41         for(int i=0;i<theLists.length;i++)
 42             theLists[i].clear();
 43         currentSize=0;
 44     }
 45     
 46     private static final int DEFAULT_TABLE_SIZE=101;
 47     
 48     private List<T> [] theLists;
 49     private int currentSize;
 50     
 51     /*
 52      * 哈希表扩容，表长度为下一个素数
 53      * */
 54     private void rehash() {
 55         List<T>[] oldLists=theLists;
 56         theLists=new List[nextPrime(2*theLists.length)];
 57         for(int j=0;j<theLists.length;j++)
 58             theLists[j]=new LinkedList<>();
 59         
 60         currentSize=0;
 61         /*
 62          * 更新哈希表
 63          * */
 64         for(List<T> list:oldLists)
 65             for(T item:list)
 66                 insert(item);
 67     }
 68     /*
 69      * myhash()方法获得哈希表的地址
 70      * */
 71     private int myhash(T x) {
 72         int hashVal=x.hashCode();//hashCode()方法返回该对象的哈希码值
 73         hashVal%=theLists.length;//对哈希表长度取余数
 74         if(hashVal<0)
 75             hashVal+=theLists.length;
 76         return hashVal;
 77     }
 78     //下一个素数
 79     private static int nextPrime(int n) {
 80         if( n % 2 == 0 )
 81             n++;
 82 
 83         for( ; !isPrime( n ); n += 2 )
 84             ;
 85 
 86         return n;
 87     }
 88     //判断是否是素数
 89     private static boolean isPrime(int n) {
 90          if( n == 2 || n == 3 )
 91                 return true;
 92 
 93             if( n == 1 || n % 2 == 0 )
 94                 return false;
 95 
 96             for( int i = 3; i * i <= n; i += 2 )
 97                 if( n % i == 0 )
 98                     return false;
 99 
100             return true;
101     }
102 }
View Code

 

posted @ 2017-11-29 14:12  xpang0  阅读(3501)  评论(0)  编辑  收藏  举报