C Program To Implement Dictionary Using Hashing Algorithms -

In separate chaining, each bucket of the hash table contains a linked list (or another dynamic data structure) of key-value pairs that hash to that index. When a collision occurs, the new pair is simply appended to the list.

Advantages:

Disadvantages:

In C, a chaining-based dictionary might define nodes as:

typedef struct Entry 
    char *key;
    int value;
    struct Entry *next;
 Entry;
Entry *hashTable[TABLE_SIZE];

Insertion involves hashing the key, then prepending or appending to the list at hashTable[index]. Search requires traversing the list until the matching key is found.

A hash-based dictionary operates on a simple yet powerful principle: a hash function transforms a key (which could be a string, integer, or any data) into an integer, known as a hash code. This hash code is then mapped to an index within a fixed-size array, often called the hash table. The key-value pair is stored at that index. To retrieve a value given a key, the same hash function is applied, and the program directly probes the computed index.

In C, the dictionary structure typically consists of: c program to implement dictionary using hashing algorithms

void free_dict(HashTable *dict) 
    for (int i = 0; i < dict->size; i++) 
        Entry *curr = dict->buckets[i];
        while (curr) 
            Entry *temp = curr;
            curr = curr->next;
            free(temp->key);
            free(temp);
free(dict->buckets);
    free(dict);

First, define the linked list node for the chain:

typedef struct Entry 
    char *key;
    char *value;
    struct Entry *next;
 Entry;

Next, define the hash table structure:

typedef struct Dictionary 
    Entry **buckets;    // Array of pointers to linked lists
    unsigned long size; // Current number of buckets
    unsigned long count; // Number of key-value pairs stored
    unsigned long (*hash_func)(const char *); // Function pointer for hash algorithm
 Dictionary;

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define TABLE_SIZE 101
// A key-value pair node
typedef struct Entry 
char* key;
int value;
struct Entry* next;
 Entry; In separate chaining, each bucket of the hash
// Dictionary structure
typedef struct 
Entry** buckets;
int size;      // number of buckets (table size)
int count;     // number of key-value pairs stored
 Dictionary;

Total number of key-value pairs: 3

We need three primary structures: