开放地址法

哈希表在压缩可选值后仍有冲突的可能，比如1和101，二者最后的取余仍为1，会导致冲突，解决这种冲突的一种方法就是开放地址法。

开放地址法：当冲突法生时，通过查找数组的一个空位，并将数据填入，而不再用哈希函数得到的数组下表

简单的理解：就是当发生冲突的时候，比如1和101,1占据了一个位置，101进入时候就向下查找，找到下面的一个空位插入，如果没有继续查找空位，知道找到为止并进行插入。

代码实现：

初始化

/**
* 员工信息类
* @author Administrator
*
*/
public class Info {
   private String key;
   private String name;

   public Info(String key, String name) {
       this.key = key;
       this.name = name;
   }

   public String getKey() {
       return key;
   }

   public void setKey(String key) {
       this.key = key;
   }

   public String getName() {
       return name;
   }

   public void setName(String name) {
       this.name = name;
   }


}

定义方法

import java.math.BigInteger;

public class HashTable {
   private Info[] arr;

   /**
   * 默认的构造方法
   */
   public HashTable() {
       arr = new Info[100];
   }

   /**
   * 指定数组初始化大小
   */
   public HashTable(int maxSize) {
       arr = new Info[maxSize];
   }

   /**
   * 插入数据
   */
   public void insert(Info info) {
       //获得关键字
       String key = info.getKey();
       //关键字所自定的哈希数
       int hashVal = hashCode(key);
       //如果这个索引已经被占用，而且里面是一个未被删除的数据
       while(arr[hashVal] != null && arr[hashVal].getName() != null) {
           //进行递加
           ++hashVal;
           //循环
           hashVal %= arr.length;
       }
       arr[hashVal] = info;
   }

   /**
   * 查找数据
   */
   public Info find(String key) {
       int hashVal = hashCode(key);
       while(arr[hashVal] != null) {
           if(arr[hashVal].getKey().equals(key)) {
               return arr[hashVal];
           }
           ++hashVal;
           hashVal %= arr.length;
       }
       return null;
   }

   /**
   * 删除数据
   * @param key
   * @return
   */
   public Info delete(String key) {
       int hashVal = hashCode(key);
       while(arr[hashVal] != null) {
           if(arr[hashVal].getKey().equals(key)) {
               Info tmp = arr[hashVal];
               tmp.setName(null);
               return tmp;
           }
           ++hashVal;
           hashVal %= arr.length;
       }
       return null;
   }

   public int hashCode(String key) {
//       int hashVal = 0;
//       for(int i = key.length() - 1; i >= 0; i--) {
//           int letter = key.charAt(i) - 96;
//           hashVal += letter;
//       }
//       return hashVal;

       BigInteger hashVal = new BigInteger("0");
       BigInteger pow27 = new BigInteger("1");
       for(int i = key.length() - 1; i >= 0; i--) {
           int letter = key.charAt(i) - 96;
           BigInteger letterB = new BigInteger(String.valueOf(letter));
           hashVal = hashVal.add(letterB.multiply(pow27));
           pow27 = pow27.multiply(new BigInteger(String.valueOf(27)));
       }
       return hashVal.mod(new BigInteger(String.valueOf(arr.length))).intValue();
   }
}

进行测试

public class TestHashTable {
   public static void main(String[] args) {
       HashTable ht = new HashTable();
       ht.insert(new Info("a","张三"));
       ht.insert(new Info("ct","李四"));
       ht.insert(new Info("b","王五"));

       System.out.println(ht.find("a").getName());
       System.out.println(ht.find("ct").getName());
       System.out.println(ht.find("b").getName());

       ht.delete("b");
       System.out.println(ht.find("b").getName());
   }
}

猜你喜欢