哈希表，开放地址法之再哈希代码（JAVA）

  哈希表中，一串连续的已填充单元叫做填充序列。增加越来越多的数据项时，填充序列变的越来越长，这叫做聚集。






为了消除原始聚集和二次聚集，可以使用另外的一个方法：再哈希法：一种依赖关键字的探测序列，而不是每个关键字都一样，那么，不同的关键字即使映射到相同的数组下标，也可以使用不同的探测序列。
方法是把关键字用不同的哈希函数再做一次哈希化，用这个结果作步长，对指定的关键字，步长在整个探测中是不变的，不同的关键字使用不同的步长。



数组实现的哈希表，开放地址法之再哈希法:

Java代码

1. import java.io.*;
3. class DataItem {//数据项
4. private int iData; // 数据项的关键字
6. public DataItem(int ii)
7. { iData = ii; }
9. public int getKey()
10. { return iData; }
12. }
14. class HashTable{//数组实现的哈希表，开放地址法之再哈希法
15. private DataItem[] hashArray; //存数据的数组
16. private int arraySize;
17. private DataItem nonItem; //已删除标志
19. HashTable(int size) {//哈希表构造函数
20. arraySize = size;
21. hashArray = new DataItem[arraySize];
22. nonItem = new DataItem(-1);
23. }
25. public void displayTable()//输出哈希表
26. {
27. System.out.print("Table: ");
28. for(int j=0; j<arraySize; j++)
29. {
30. if(hashArray[j] != null)
31. System.out.print(hashArray[j].getKey()+ " ");
32. else
33. System.out.print("** ");
34. }
35. System.out.println("");
36. }
38. //哈希函数1
39. public int hashFunc1(int key){
40. return key % arraySize;
41. }
43. //哈希函数2,不同于哈希函数1，用于再哈希。
44. public int hashFunc2(int key){
45. // array size must be relatively prime to 5, 4, 3, and 2
46. return 5 - key % 5;
47. }
49. //哈希表中插入数据
50. public void insert(int key, DataItem item){
51. int hashVal = hashFunc1(key); //求关键字的哈希值
52. int stepSize = hashFunc2(key); // 再探测步长的大小
54. while(hashArray[hashVal] != null && hashArray[hashVal].getKey() != -1) {
55. hashVal += stepSize; //单元被占用，再探测
56. hashVal %= arraySize;
57. }
58. hashArray[hashVal] = item;
59. }
61. //在哈希表中删除
62. public DataItem delete(int key) {
63. int hashVal = hashFunc1(key);
64. int stepSize = hashFunc2(key);
66. while(hashArray[hashVal] != null){//直到一个空单元出现
67. if(hashArray[hashVal].getKey() == key){
68. DataItem temp = hashArray[hashVal];
69. hashArray[hashVal] = nonItem; //作删除标记
70. return temp;
71. }
72. hashVal += stepSize; //再探测
73. hashVal %= arraySize;
74. }
75. return null;
76. }
78. //在哈希表中搜索
79. public DataItem find(int key){
80. int hashVal = hashFunc1(key);
81. int stepSize = hashFunc2(key);
83. while(hashArray[hashVal] != null) {
84. if(hashArray[hashVal].getKey() == key)
85. return hashArray[hashVal];
86. hashVal += stepSize;
87. hashVal %= arraySize;
88. }
89. return null;
90. }
92. }
93. public class HashDoubleApp{
94. public static void main(String[] args) throws IOException{
95. int aKey;
96. DataItem aDataItem;
97. int size, n;
99. System.out.print("Enter size of hash table: ");
100. size = getInt();
101. System.out.print("Enter initial number of items: ");
102. n = getInt();
104. HashTable theHashTable = new HashTable(size);
106. for(int j=0; j<n; j++){
107. aKey = (int)(java.lang.Math.random() * 2 * size);
108. aDataItem = new DataItem(aKey);
109. theHashTable.insert(aKey, aDataItem);
110. }
112. while(true){
113. System.out.print("Enter first letter of ");
114. System.out.print("show, insert, delete, or find: ");
115. char choice = getChar();
116. switch(choice)
117. {
118. case 's':
119. theHashTable.displayTable();
120. break;
121. case 'i':
122. System.out.print("Enter key value to insert: ");
123. aKey = getInt();
124. aDataItem = new DataItem(aKey);
125. theHashTable.insert(aKey, aDataItem);
126. break;
127. case 'd':
128. System.out.print("Enter key value to delete: ");
129. aKey = getInt();
130. theHashTable.delete(aKey);
131. break;
132. case 'f':
133. System.out.print("Enter key value to find: ");
134. aKey = getInt();
135. aDataItem = theHashTable.find(aKey);
136. if(aDataItem != null)
137. System.out.println("Found " + aKey);
138. else
139. System.out.println("Could not find " + aKey);
140. break;
141. default:
142. System.out.print("Invalid entry\n");
143. }
144. }
145. }
147. public static String getString() throws IOException
148. {
149. InputStreamReader isr = new InputStreamReader(System.in);
150. BufferedReader br = new BufferedReader(isr);
151. String s = br.readLine();
152. return s;
153. }
155. public static char getChar() throws IOException
156. {
157. String s = getString();
158. return s.charAt(0);
159. }
161. public static int getInt() throws IOException
162. {
163. String s = getString();
164. return Integer.parseInt(s);
165. }
167. }

import java.io.*;

class DataItem {//数据项                            
   private int iData;  // 数据项的关键字

   public DataItem(int ii)  
      { iData = ii; }

   public int getKey()
      { return iData; }

   } 

class HashTable{//数组实现的哈希表，开放地址法之再哈希法
   private DataItem[] hashArray; //存数据的数组
   private int arraySize;
   private DataItem nonItem;  //已删除标志

   HashTable(int size) {//哈希表构造函数 
      arraySize = size;
      hashArray = new DataItem[arraySize];
      nonItem = new DataItem(-1);
   }

   public void displayTable()//输出哈希表
      {
      System.out.print("Table: ");
      for(int j=0; j<arraySize; j++)
         {
         if(hashArray[j] != null)
            System.out.print(hashArray[j].getKey()+ " ");
         else
            System.out.print("** ");
         }
      System.out.println("");
      }

  //哈希函数1
   public int hashFunc1(int key){
      return key % arraySize;
   }

   //哈希函数2,不同于哈希函数1，用于再哈希。
   public int hashFunc2(int key){
    // array size must be relatively prime to 5, 4, 3, and 2
      return 5 - key % 5;
      }

   //哈希表中插入数据
   public void insert(int key, DataItem item){
      int hashVal = hashFunc1(key);  //求关键字的哈希值
      int stepSize = hashFunc2(key); // 再探测步长的大小
                                   
      while(hashArray[hashVal] != null && hashArray[hashVal].getKey() != -1) {
         hashVal += stepSize;   //单元被占用，再探测   
         hashVal %= arraySize;    
         }
      hashArray[hashVal] = item;    
      } 

   //在哈希表中删除
   public DataItem delete(int key) {
      int hashVal = hashFunc1(key);  
      int stepSize = hashFunc2(key);  

      while(hashArray[hashVal] != null){//直到一个空单元出现
          if(hashArray[hashVal].getKey() == key){
            DataItem temp = hashArray[hashVal]; 
            hashArray[hashVal] = nonItem;  //作删除标记
            return temp;     
            }
         hashVal += stepSize; //再探测
         hashVal %= arraySize;  
         }
      return null;        
      }  

   //在哈希表中搜索
   public DataItem find(int key){
      int hashVal = hashFunc1(key);  
      int stepSize = hashFunc2(key);  

      while(hashArray[hashVal] != null) { 
         if(hashArray[hashVal].getKey() == key)
            return hashArray[hashVal]; 
         hashVal += stepSize;  
         hashVal %= arraySize;  
         }
      return null;    
      }

   } 
 public class HashDoubleApp{
   public static void main(String[] args) throws IOException{
      int aKey;
      DataItem aDataItem;
      int size, n;
                      
      System.out.print("Enter size of hash table: ");
      size = getInt();
      System.out.print("Enter initial number of items: ");
      n = getInt();
                               
      HashTable theHashTable = new HashTable(size);

      for(int j=0; j<n; j++){
         aKey = (int)(java.lang.Math.random() * 2 * size);
         aDataItem = new DataItem(aKey);
         theHashTable.insert(aKey, aDataItem);
      }

      while(true){
         System.out.print("Enter first letter of ");
         System.out.print("show, insert, delete, or find: ");
         char choice = getChar();
         switch(choice)
            {
            case 's':
               theHashTable.displayTable();
               break;
            case 'i':
               System.out.print("Enter key value to insert: ");
               aKey = getInt();
               aDataItem = new DataItem(aKey);
               theHashTable.insert(aKey, aDataItem);
               break;
            case 'd':
               System.out.print("Enter key value to delete: ");
               aKey = getInt();
               theHashTable.delete(aKey);
               break;
            case 'f':
               System.out.print("Enter key value to find: ");
               aKey = getInt();
               aDataItem = theHashTable.find(aKey);
               if(aDataItem != null)
                  System.out.println("Found " + aKey);
               else
                  System.out.println("Could not find " + aKey);
               break;
            default:
               System.out.print("Invalid entry\n");
            }  
         }  
      }  

   public static String getString() throws IOException
      {
      InputStreamReader isr = new InputStreamReader(System.in);
      BufferedReader br = new BufferedReader(isr);
      String s = br.readLine();
      return s;
      }

   public static char getChar() throws IOException
      {
      String s = getString();
      return s.charAt(0);
      }

   public static int getInt() throws IOException
      {
      String s = getString();
      return Integer.parseInt(s);
      }

   }