Question

in java, Hash 8 randomly generated int values (in the range [ 0 - 99 ] inclusive).

The random number generator is initially seeded to value 97.

Each generated value is stored in a hash table size 11.

The first hash function, h1(key) is the division modulo sizeof(table).

I.e., h1(key) = key % sizeof(table)

h1(key) = key % 11.

Any collisions will NOT be stored in the hash table. You will ignore collisions.

The hash table is a random access file used to store 1D table of 11 ints.

The output:

After all values are hashed, print the table's contents. Each entry will

be outputted in the form:

byte offset int index int value

Constraints:

(0) You must use a random access file. An in-memory hash table or in memory

1D array implementation will receive zero credit.

(1) Use exactly one random number generator.

(2) Duplicate data is permitted.

(3) Only one Java file.

(4) Include the standard header.

(5) Minimal (or no) comments.

Answer 1

import java.util.Random;

public class Hashing {

int hashTable[] = new int[11];
  
public Hashing() {
for(int inx=0;inx < hashTable.length;inx++){
hashTable[inx] = -1;
}
}
  
private int firstHashFunction(int key)
{
int hashValue = -1;
hashValue = key%hashTable.length;
return hashValue;
}
  
private int secondHashFunction(int key)
{
int hashValue = -1;
hashValue = 7 - (key % 7);
return hashValue;
}
  
public void addKeyToHash(int key)
{
int location = firstHashFunction(key);
if(hashTable[location] != -1 )
{
location = secondHashFunction(key);
}
hashTable[location] = key;
System.out.println(key+" , "+ location);
}
  
public void displayHashTable()
{
System.out.println("Hash Table");
for(int inx=0;inx<hashTable.length;inx++)
{
System.out.println(hashTable[inx]);
}
}
  
public static void main(String[] args) {
Hashing h = new Hashing();
Random r = new Random();
for(int inx=0; inx < 8 ; inx++ )
{
int randomNumber;
randomNumber = (inx==0)? r.nextInt(97) : r.nextInt(100);
h.addKeyToHash(randomNumber);
}
h.displayHashTable();
}
}

OUTPUT: