Hash table with linear probing : HashTable Map : Collections Data Structure : Java examples (example source code) Organized by topic

Java
C++
PHP


Java  »  Collections Data Structure   » [  HashTable Map  ]  Screenshots 
 



Hash table with linear probing



import java.io.IOException;

public class HashTable {
  private DataItem[] hashArray; 

  private int arraySize;

  private DataItem bufItem; // for deleted items

  public HashTable(int size) {
    arraySize = size;
    hashArray = new DataItem[arraySize];
    bufItem = new DataItem(-1)// deleted item key is -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 hashFunction(int key) {
    return key % arraySize; 
  }

  public void insert(DataItem item){
    int key = item.getKey()
    int hashVal = hashFunction(key)// hash the key
    // until empty cell or -1,
    while (hashArray[hashVal!= null && hashArray[hashVal].getKey() != -1) {
      ++hashVal; // go to next cell
      hashVal %= arraySize; // wraparound if necessary
    }
    hashArray[hashVal= item; // insert item
  }

  public DataItem delete(int key) {
    int hashVal = hashFunction(key)

    while (hashArray[hashVal!= null// until empty cell,
    
      if (hashArray[hashVal].getKey() == key) {
        DataItem temp = hashArray[hashVal]// save item
        hashArray[hashVal= bufItem; // delete item
        return temp;
      }
      ++hashVal; // go to next cell
      hashVal %= arraySize; // wraparound if necessary
    }
    return null// can't find item
  }

  public DataItem find(int key// find item with key
  {
    int hashVal = hashFunction(key)// hash the key

    while (hashArray[hashVal!= null// until empty cell,
    
      if (hashArray[hashVal].getKey() == key)
        return hashArray[hashVal]// found, return item
      ++hashVal; // go to next cell
      hashVal %= arraySize; // wraparound if necessary
    }
    return null// can't find item
  }

  public static void main(String[] argsthrows IOException {
    DataItem aDataItem;
    int aKey, size, initSize, keysPerCell;

    size = 150;
    initSize = 100;
    keysPerCell = 10;
    HashTable theHashTable = new HashTable(size);

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

    theHashTable.displayTable();
    aDataItem = new DataItem(100);
    theHashTable.insert(aDataItem);

    theHashTable.delete(100);
    aDataItem = theHashTable.find(100);
    if (aDataItem != null) {
      System.out.println("Found " 100);
    else
      System.out.println("Could not find " 100);
  }
}
class DataItem 
  private int data; 

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

  public int getKey() {
    return data;
  }
}


           
       
Related examples in the same category
1.  Associates keys with values Associates keys with values
2.  A simple Map implementation A simple Map implementation
3.  Hash table with separate chaining
4.  Hash table with double hashing Hash table with double hashing
5.  Working with Key-Value Pairs in a Hashtable
6.  Demonstrate the Hashtable class, and an Enumeration
7.  Demonstrate the HashMap class, and an Iterator Demonstrate the HashMap class, and an Iterator
8.  Soft HashMap
9.  MultiMap extends AbstractMap
10.  Array Map extends AbstractMap Array Map extends AbstractMap
11.  Demonstrating the WeakHashMap Demonstrating the WeakHashMap
12.  Use treemap Use treemap
13.  Sorting Elements in a TreeMap Sorting Elements in a TreeMap
14.  What you can do with a TreeMap What you can do with a TreeMap
15.  A Map implemented with ArrayLists
16.  Simple demonstration of HashMap Simple demonstration of HashMap
























Home| Contact Us
Copyright 2003 - 07 Demo Source and Support. All rights reserved.
All other trademarks are property of their respective owners.