Question

(in Java) We wish to insert the following strings into a hash table: BEN AL SUE CHUCK KAREN MIKE SAM MIKE ALICE TARA TIM BOB Let's make the hash table size p=19 ( 19 is a prime ). Use letter encodings where A maps to 1, B maps to 2, etc and strings map to powers of 26. For example, "ABC" would map to 1*(26^2) + 2*(26^1)+ 3*(26^0) mod 19 (you might find the web site Wolfram Alpha helpful. Just type in the expression as shown here).

a) show the hash tanle using linear probing

b) show the hash table using quadratic probing

c) show the hash table using a rehashing function. The rehashing function should be stepSize = 7 - (f(s) mod 7)

d) which of the three resolution techniques worked the best? Support your answer.

Answer 1

import java.io.*;
import java.util.*;
import java.text.*;
import java.math.*;
import java.util.regex.*;

public class Solution {
  
static int linear_probing(int ar[], int n, int p){
int count = 0;
String hash[] = new String[p];
  
for(int i=0;i<p;i++){
hash[i] = -1;
}
  
for(int i=0;i<n;i++){
long int hash_value = 0;
for(int j=0;j<ar[i].length();j++){
hash_value += (ar[i].charAt(j) - 64) * Math.pow(26, j+1);
}
int index = hash_value % p;
if(hash[index] == -1){
hash[index] = ar[i];
}else{
count++;
while(hash[index] != -1){
index = (index + 1) % p;
}
hash[index] = ar[i];
}
}
return count;
}
  
static int quadratic_probing(int ar[], int n, int p){
int count = 0;
String hash[] = new String[p];
  
for(int i=0;i<p;i++){
hash[i] = -1;
}
  
for(int i=0;i<n;i++){
long int hash_value = 0;
for(int j=0;j<ar[i].length();j++){
hash_value += (ar[i].charAt(j) - 64) * Math.pow(26, j+1);
}
int index = hash_value % p;
if(hash[index] == -1){
hash[index] = ar[i];
}else{
count++;
int k = 1;
while(hash[index] != -1){
index = (index + power(k, 2)) % p;
k++;
}
hash[index] = ar[i];
}
}
return count;
}
  
static int rehashing(int ar[], int n, int p){
int count = 0;
String hash[] = new String[p];
  
for(int i=0;i<p;i++){
hash[i] = -1;
}
  
for(int i=0;i<n;i++){
long int hash_value = 0;
for(int j=0;j<ar[i].length();j++){
hash_value += (ar[i].charAt(j) - 64) * Math.pow(26, j+1);
}
int index = hash_value % p;
if(hash[index] == -1){
hash[index] = ar[i];
}else{
count++;
while(hash[index] != -1){
index = (index + (7 - (hash_value % 7)) % p;
}
hash[index] = ar[i];
}
}
return count;
}

public static void main(String[] args) {
int n;
Scanner s = new Scanner(System.in);
n = s.netInt();
String ar = new String[n];
for(int i=0;i<n;i++){
ar[i] = s.next();
}
int p;
s = p.nextint();
int linear_collisions = linear_probing(ar, n, p);
int quadratic_collisions = quadratic_collisions(ar, n, p);
int rehashing_collisions = rehashing(ar, n, p);
}
}

When we run the algorithm, we can evidently see that the number of collision in linaer probing is greater than the number of collisions in quadratic probing is greater than the number of collisions in rehashing. Hence, rehashing is a better algorithm when compared to other algorithms.