Hash talbe 多重散列（Double Hashing）

Double hashing

From Wikipedia, the free encyclopedia

Jump to: navigation , search

Double hashing is a computer programming technique used in hash tables to resolve hash collisions, cases when two different values to be searched for produce the same hash key. It is a popular collision-resolution technique in open-addressed hash tables.

Like linear probing, it uses one hash value as a starting point and then repeatedly steps forward an interval until the desired value is located, an empty location is reached, or the entire table has been searched; but this interval is decided using a second, independent hash function (hence the name double hashing). Unlike linear probing and quadratic probing, the interval depends on the data, so that even values mapping to the same location have different bucket sequences; this minimizes repeated collisions and the effects of clustering. In other words, given independent hash functions h₁ and h₂, the jth location in the bucket sequence for value k in a hash table of size m is:

[edit] Disadvantages

Linear probing and, to a lesser extent, quadratic probing are able to take advantage of the data cache by accessing locations that are close together. Double hashing has larger intervals and is not able to achieve this advantage.

Deletions are also complex in a double-hashed hash table. After a collision has occurred for a certain slot, its contents cannot be deleted or all sequences crossing that slot may be severed. Instead, a delete marker known as a tombstone will be put in its place, filling up a slot and slightly degrading search performance. While tombstones can be reused on a later insertion, it is prudent to rebuild the table if the number of tombstones becomes too large.

Like all other forms of open addressing, double hashing becomes linear as the hash table approaches maximum capacity. The only solution to this is to rehash to a larger size.

[edit] See also

• Hash collision
• Hash function
• Linear probing
• Cuckoo hashing

[edit] External links

• How Caching Affects Hashing by Gregory L. Heileman and Wenbin Luo 2005.

 This data structure-related article is a stub. You can help Wikipedia by expanding it.

Retrieved from " http://en.wikipedia.org/wiki/Double_hashing "

算法定义 http://baike.baidu.com/view/1207363.html

import java.io.IOException;

public class HashTableWithDoubleHashing {
  private DataItem[] hashArray; 

  private int arraySize;

  private DataItem bufItem; // for deleted items

  HashTableWithDoubleHashing(int size) {
    arraySize = size;
    hashArray = new DataItem[arraySize];
    bufItem = 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("");
  }

  public int hashFunc1(int key) {
    return key % arraySize;
  }

  public int hashFunc2(int key) {
    return 6 - key % 6;
  }

  public void insert(int key, DataItem item) {
    int hashVal = hashFunc1(key); // hash the key
    int stepSize = hashFunc2(key); // get step size
    // until empty cell or -1
    while (hashArray[hashVal] != null && hashArray[hashVal].getKey() != -1) {
      hashVal += stepSize; // add the step
      hashVal %= arraySize; // for wraparound
    }
    hashArray[hashVal] = item; // insert item
  }

  public DataItem delete(int key) {
    int hashVal = hashFunc1(key); 
    int stepSize = hashFunc2(key); // get step size

    while (hashArray[hashVal] != null) {
      if (hashArray[hashVal].getKey() == key) {
        DataItem temp = hashArray[hashVal]; // save item
        hashArray[hashVal] = bufItem; // delete item
        return temp; // return item
      }
      hashVal += stepSize; // add the step
      hashVal %= arraySize; // for wraparound
    }
    return null; // can't find item
  }

  public DataItem find(int key) {
    int hashVal = hashFunc1(key); // hash the key
    int stepSize = hashFunc2(key); // get step size

    while (hashArray[hashVal] != null) {
      if (hashArray[hashVal].getKey() == key)
        return hashArray[hashVal]; // yes, return item
      hashVal += stepSize; // add the step
      hashVal %= arraySize; // for wraparound
    }
    return null; // can't find item
  }

  public static void main(String[] args) throws IOException {
    int aKey;
    DataItem aDataItem;
    int size, initSize;
    size = 100;
    initSize = 10;
    HashTableWithDoubleHashing theHashTable = new HashTableWithDoubleHashing(
        size);
    for (int i = 0; i < initSize; i++) {
      aKey = (int) (java.lang.Math.random() * 2 * size);
      aDataItem = new DataItem(aKey);
      theHashTable.insert(aKey, aDataItem);
    }

    theHashTable.displayTable();
    aKey = 100;
    aDataItem = new DataItem(aKey);
    theHashTable.insert(aKey, aDataItem);
    aKey = 100;
    theHashTable.delete(aKey);
    aKey = 100;
    aDataItem = theHashTable.find(aKey);
    if (aDataItem != null)
      System.out.println("Found " + aKey);
    else
      System.out.println("Could not find " + aKey);
  }

}

class DataItem {
  private int data;

  public DataItem(int i) {
    data = i;
  }

  public int getKey() {
    return data;
  }

}