#include <stdio.h>
#include <string.h>
#include <stdlib.h>
struct hash * hashTable = NULL;
int eleCount = 100 ;
struct node {
int key, value;
struct node * next;
} ;
struct hash {
struct node * head;
int count;
} ;
struct node * createNode( int key, int value) {
struct node * newnode;
newnode
= ( struct node
* ) malloc ( sizeof ( struct node
) ) ; newnode-> key = key;
newnode-> value = value;
newnode-> next = NULL;
return newnode;
}
void insertToHash( int key, int value) {
int hashIndex = key % eleCount;
struct node * newnode = createNode( key, value) ;
//for first entry
if ( ! hashTable[ hashIndex] .head ) {
hashTable[ hashIndex] .head = newnode;
hashTable[ hashIndex] .count = 1 ;
return ;
}
struct node * temp = hashTable[ hashIndex] .head ;
//checking for same key number and updating its value
while ( temp) {
if ( temp-> key== key) {
temp-> value = value;
return ;
}
temp = temp-> next;
}
//creating a new node in the LL
hashTable[ hashIndex] .head -> next = newnode;
hashTable[ hashIndex] .count ++;
return ;
}
void deleteFromHash( int key) {
int hashIndex = key % eleCount;
struct node * temp, * myNode;
myNode = hashTable[ hashIndex] .head ;
if ( ! myNode) {
printf ( "Given data is not present in hash Table!!\n " ) ; return ;
}
temp = myNode;
while ( myNode) {
if ( myNode-> key == key) {
//first element of LL
if ( myNode == hashTable[ hashIndex] .head )
hashTable[ hashIndex] .head = myNode-> next;
//second to last element of LL
else
temp-> next = myNode-> next;
hashTable[ hashIndex] .count --;
break ;
}
temp = myNode;
myNode = myNode-> next;
}
return ;
}
void searchInHash( int key) {
int hashIndex = key % eleCount;
struct node * myNode;
myNode = hashTable[ hashIndex] .head ;
if ( ! myNode) {
printf ( "Search element unavailable in hash table\n " ) ; return ;
}
while ( myNode) {
if ( myNode-> key == key) {
printf ( "Value: %d\n " , myNode
-> value
) ; break ;
}
myNode = myNode-> next;
}
return ;
}
void display( ) {
struct node * myNode;
int i;
for ( i = 0 ; i < eleCount; i++ ) {
if ( hashTable[ i] .count == 0 )
continue ;
myNode = hashTable[ i] .head ;
printf ( "\n Data at index %d in Hash Table:\n " , i
) ; while ( myNode != NULL) {
printf ( "Key %d : Value %d\n " , myNode
-> key
, myNode
-> value
) ; myNode = myNode-> next;
}
}
return ;
}
int main( ) {
int ch, key, value;
hashTable
= ( struct hash
* ) calloc ( eleCount
, sizeof ( struct hash
) ) ; while ( 1 ) {
printf ( "\n 1. Insertion\t 2. Deletion\n " ) ; printf ( "3. Searching\t 4. Display\n 5. Exit\n " ) ; printf ( "Enter your choice:\n " ) ; switch ( ch) {
case 1 :
printf ( "Enter the key number:\n " ) ; printf ( "Enter the value number:\n " ) ; insertToHash( key, value) ;
break ;
case 2 :
printf ( "Enter the key to perform deletion:\n " ) ; /* delete node with "key" from hash table */
deleteFromHash( key) ;
break ;
case 3 :
printf ( "Enter the key to search:\n " ) ; searchInHash( key) ;
break ;
case 4 :
display( ) ;
break ;
case 5 :
default :
printf ( "You have entered wrong option!!\n " ) ; break ;
}
}
return 0 ;
}
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