National University of Computer and Emerging Sciences

Lab-12
Data Structures

Course Instructor Saifullah Tanvir

Lab Instructor(s) Muhammad Ahmed Khan

Talha Azhar

Quiz-02 Hashing

Section BS(CS) 3K

Department of Computer Science

FAST-NU, Lahore, Pakistan

In this lab, you are going to implement a class for Hash Table. The class definitions will look like:

class HashTable;

class HashItem

friend class HashTable;

private:

int key; // index where your value will be stored

string value; //actual value to be stored in HashTable

int status; // 0: Empty, 1: Deleted, 2: Occupied

};

class HashTable

private:

HashItem* hashArray;

int capacity;

int currentElements;

int getNextCandidateIndex(int key, int i);

void doubleCapacity()

public:

HashTable();

HashTable(int const capacity);

void insert(int const key, string const value);

bool deleteKey(int const key) const;

string get(int const key) const;

~HashTable();

};
About HashItem class:
It represents an item (key-value pair) to be inserted in a hash table. The status variable can have

0, 1 or 2. 0 means empty, 1 means deleted, 2 means occupied. Status variable will be used by get

and delete methods of HashTable implemented in the next questions. The default value assigned

to a HashItem is 0 (empty).

About HashTable class:

As, all of the private functions’ prototypes are already given for your reference. You need to

implement this class in this lab. All questions (which you see below) divides this task in parts.

Question1:
Implement the two constructors (default and overloaded), and destructor of the class
HashTable.

1. HashTable(): constructor assigns a capacity of 10 to hashArray.

2. HashTable(int const capacity): an overloaded constructor that assigns the capacity of
given capacity to hashArray. If capacity is less than 1 return error message
3. ~HashTable(): destructor

Question2:
Now, implement these functions which are given below, and are required for helping in handling

collision, and also in insert and delete methods.

int getNextCandidateIndex(int key, int i): a private method that uses linear probing to return

the next candidate index for storing the item containing key k. Linear probing means that it will

simply add i to the hash value of key. This method does not check whether the candidate index

has collision or not.

void doubleCapacity(): A private method which doubles the capacity of hash array and
rehashes

the existing items (Remember we have a dynamic hash array). Use getNextCandidateIndex

method to resolve collision.

Question3:
Implement the public insert function

void insert(int const key, v const value):

a. The insert method inserts the value at its appropriate location. Find the first candidate

index of the key using:

index= key mod capacity

b. To resolve hash collision, it will use the function getNextCandidateIndex(key, i) to get the

next candidate index. If the candidate index also has collision, then getNextCandidateIndex will
be called again with an increment in i. getNextCandidateIndex will be continued to call until we
find a valid index. Initially i will be 1.

c. If the loadFactor becomes 0.75, then it will call the doubleCapacity method to double the

capacity of array and rehash the existing items into the new array.

Hint: To check load factor, the overall formula used will be currentElements >= 0.75 * capacity

Question 4:
Implement the following functions for deletion of a given value from the hash table and

searching the value in hash table:

bool deleteKey(int const key) const;

This method deletes the given key. It returns true if the key was found. If the key was not found

it returns false. When the key is found, simply set the status of the hashItem containing the key

to deleted (value of 1). It also uses status variable to search for the key intelligently ��

string get(int const key) const

This method returns the value of the key. If the key is not found, it returns a message saying
“not found”. It also uses status variable to search for the key intelligently.

Question 5:
Rewrite the class in such a way that it performs Quadratic Probing, i.e., add the square of i to

the hash value of key.

Hint: You have to change getNextCandidateIndex(int key, int i) method

Test all your functions through this main:

int main() {

HashTable hashtable(5); // Create a hash map with capacity 5 (for simplicity, using string as
the value type)

// Insert key-value pairs into the hash map

hashtable.insert(101, "Alice");

hashtable.insert(201, "Bob");

hashtable.insert(301, "Charlie");

hashtable.insert(401, "David");

hashtable.insert(501, "Eva");

// Test get function

string name = hashtable.get(201);

if (name.length()!=0) {

cout << "Value at key 201: " << name << endl;

else {

cout << name << endl;

// Test deleteKey function

bool deleted = hashtable.deleteKey(301);

if (deleted) {

cout << "Key 301 deleted successfully." << endl;

else {

cout << "Key 301 not found!" << endl;

// Test get after deletion

name = hashtable.get(301);

if (name.length()!=0) {

cout << "Value at key 301: " << name << endl; // Should not be found after deletion

else {

cout << name << endl;

return 0;