Write a hash function to implement a digit-folding approach in the hash function. Your program should...

Question

Question

Write a hash function to implement a digit-folding approach in the hash function. Your program should...

Write a hash function to implement a digit-folding approach in the hash
function. Your program should work for any array size and any key length.
Use linear probing. Accessing a group of digits in a number may be easier
than you think. Does it matter if the array size is not a multiple of 10?
#java#withcomments please

engineering Computer-Science

Add a comment Improve this question Transcribed image text

Answer 1

Answer #1

import java.io.*;

// Defines a class Items

class Items

{

// Instance variable to store string data

private String stringData;

// Parameterized constructor to assign parameter data to instance variable

public Items(String str)

{

stringData = str;

}// End of method

// Method to return data

public String getKeyData()

{

return stringData;

}// End of method

}// End of class Items

// Defines class to CreateHashTable

class CreateHashTable

{

private Items[] hashArray;

private int arraySize;

private Items nonAvailableItem;

// Parameterized constructor to create hash table

public CreateHashTable(int newSize)

{

arraySize = newSize;

hashArray = new Items[arraySize];

// Deleted item key is a dash

nonAvailableItem = new Items("-");

// Loops till size

for(int counter = 0; counter < newSize; counter++)

hashArray[counter] = new Items(nonAvailableItem.getKeyData());

}// End of constructor

// Method to display hash table

public void displayHahsTable()

{

System.out.print("Table: \n");

// Loops till array size

for(int counter = 0; counter < arraySize; counter++)

{

// Checks if current counter index position value is not null

if(hashArray[counter] != null)

System.out.println(hashArray[counter].getKeyData() + " ");

// Otherwise it is null

else

System.out.print("** ");

}// End of for loop

System.out.println();

}// End of method

// Method to generate a hash and return hash value from a given string

// passed as parameter

public int hashFunction(String currentKey)

{

int hashValue = 0;

// Loops till key size

for(int counter = 0; counter < currentKey.length(); counter++)

{

int letter = currentKey.charAt(counter);

hashValue = (hashValue * 27 + letter) % arraySize;

}// End of for loop

return hashValue;

}// End of method

// Method to insert an item to hash table

public void insertItem(Items newItem)

{

// Assumes table not full

// Calls the method to get the data

String currentKey = newItem.getKeyData();

// Calls the method to get the hash value

int hashValue = hashFunction(currentKey);

// Loops till current hashValue index position value is not "-"

while(hashArray[hashValue].getKeyData() != "-")

{

// Increase the hash value by one

++hashValue;

// Calculates the hash value by getting remainder of array size

hashValue %= arraySize;

}// End of while loop

// Assigns the parameter newItem at hashValue index position

hashArray[hashValue] = newItem;

}// End of method

// Method to delete an item from hash table

public Items deleteItem(String currentKey)

{

// Calls the function to get the hash value of the parameter currentKey

int hashValue = hashFunction(currentKey);

// Loops till current hashValue index position value is not "-"

// and current hashValue index position value is not null

while(hashArray[hashValue].getKeyData() != "-" &&

hashArray[hashValue].getKeyData() != null)

{

// Checks current hashValue index position value is equals

// to the parameter currentKey value

if(hashArray[hashValue].getKeyData().equals(currentKey))

{

// Assigns the data to temporary key

Items tempKey = hashArray[hashValue];

// Assigns the nonAvailableItem i.e., "-" at

// hash value index position

hashArray[hashValue] = nonAvailableItem;

return tempKey;

}// End of if condition

// Increase the hash value by one

++hashValue;

// Calculates the hash value by getting remainder of array size

hashValue %= arraySize;

}// End of while loop

return null;

}// End of method

// Method to search an item from the hash table

public Items searchItem(String currentKey)

{

// Calls the function to get the hash value of the parameter currentKey

int hashValue = hashFunction(currentKey);

// Loops till current hashValue index position value is not "-"

// and current hashValue index position value is not null

while(hashArray[hashValue].getKeyData() != "-" &&

hashArray[hashValue].getKeyData() != null)

{

// Checks current hashValue index position value is equals

// to the parameter currentKey value

if(hashArray[hashValue].getKeyData().equals(currentKey))

return hashArray[hashValue];

// Increase the hash value by one

++hashValue;

// Calculates the hash value by getting remainder of array size

hashValue %= arraySize;

}// End of while loop

return null;

}// End of method

}// End class CreateHashTable

// Driver class FoldingHashTableLinearProbing definition

public class FoldingHashTableLinearProbing

{

// Method to accept and return a string

public static String getString() throws IOException

{

InputStreamReader inpStrRed = new InputStreamReader(System.in);

BufferedReader br = new BufferedReader(inpStrRed);

String str = br.readLine();

return str;

}// End of method

// Method to accept a string and return a character

public static char getCharacter() throws IOException

{

String str = getString();

return str.charAt(0);

}// End of method

// Method to accept a string and return a integer

public static int getInteger() throws IOException

{

String str = getString();

return Integer.parseInt(str);

}// End of method

// main method definition

public static void main(String[] args) throws IOException

{

// Declares an object of class Items

Items newDataItem;

int maximumSize, initialNum, keysPerCell;

String currentKey;

// Accepts the table size

System.out.print("Enter size of hash table: ");

maximumSize = getInteger();

// Accepts initial number of items

System.out.print("Enter initial number of items: ");

initialNum = getInteger();

keysPerCell = 20;

// Creates an object of the class CreateHashTable with maximum size

CreateHashTable theHashTable = new CreateHashTable(maximumSize);

// Loops till initial numbers entered by the user

for(int counter = 0; counter < initialNum; counter++)

{

currentKey = Double.toString((java.lang.Math.random() *

keysPerCell * maximumSize));

newDataItem = new Items(currentKey);

theHashTable.insertItem(newDataItem);

}// End of for loop

// Loops infinite times

while(true)

{

// Displays menu

System.out.print("\n\n ********* MENU *********" +

"\n (S)how Result, (I)nsert Data, (D)elete Data, (F)ind Data " +

" (Q)uit." +

"\n Enter first letter: ");

// Accepts user choice

char userChoice = getCharacter();

// Checks user choice and calls appropriate method

switch(userChoice)

{

case 'S':

case 's':

theHashTable.displayHahsTable();

break;

case 'I':

case 'i':

System.out.print("Enter string to Insert: ");

currentKey = getString();

newDataItem = new Items(currentKey);

theHashTable.insertItem(newDataItem);

break;

case 'D':

case 'd':

System.out.print("Enter string to Delete: ");

currentKey = getString();

theHashTable.deleteItem(currentKey);

break;

case 'F':

case 'f':

System.out.print("Enter string to Search: ");

currentKey = getString();

newDataItem = theHashTable.searchItem(currentKey);

if(newDataItem != null)

System.out.println("Found " + currentKey);

else

System.out.println("Could not find " + currentKey);

break;

case 'Q':

case 'q':

System.exit(0);

default:

System.out.println("Invalid choice..........");

}// End of switch - case

}// End of while loop

}// End of main method

}// End of class CreateHashTable

Sample Output:

Enter size of hash table: 10
Enter initial number of items: 2

********* MENU *********
(S)how Result, (I)nsert Data, (D)elete Data, (F)ind Data (Q)uit.
Enter first letter: i
Enter string to Insert: this